@tacuchi/agent-workflow-cli 23.0.0 → 25.0.0

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

@@ -23,7 +23,7 @@ PLAN
 `/w:plan-exec` — **resumable** (same chassis mechanism; here resume keys off the plan-doc phase states + checkboxes + CHECKPOINT, see Delta 1).
 
 ## Reads
-`docs/plans/PPP-plan-<slug>.md` (locate via the `docs/plans/PPP-plan-*.md` glob or the exact path from the command argument) **and its source spec** (resolved through the plan's `## Origin`) — the entry gate reads both. It runs any plan whose source contract is executable: `> Límite de ejecución: checkout`, explicit phase/task sources and aliases from `AGENTS.md > Fuentes`. A legacy or v21 plan that lacks it fails closed to [`plan-refine-loop`](../plan-refine-loop/LOOP.md); plan-refine remains auxiliary only after that contract exists. If the plan pins design, it also reads the **UI Design Package** revisions its `## Design references` and its tasks name — **read-only**, at the exact revision each one fixed (§ *Design precondition gate*).
+`docs/plans/PPP-plan-<slug>.md` (the `docs/plans/PPP-plan-*.md` glob, or the given path) **and its source spec** (from its `> Derived from`, else one in `## Origin`; none if `> Standalone:`) — the entry gate reads both. It runs any plan whose source contract is executable: `> Límite de ejecución: checkout`, explicit phase/task sources and aliases from `AGENTS.md > Fuentes`. A legacy or v21 plan that lacks it fails closed to [`plan-refine-loop`](../plan-refine-loop/LOOP.md); plan-refine remains auxiliary only after that contract exists. If the plan pins design, it also reads the **UI Design Package** revisions its `## Design references` and its tasks name — **read-only**, at the exact revision each one fixed (§ *Design precondition gate*).
 
 ## Writes
 - `docs/plans/PPP-plan-<slug>.md` (**read/update**, living doc: phase/task state, `Open questions`).
@@ -145,9 +145,11 @@ This gate lives **only** in this loop — the chassis does not carry it. It has
 run stops at it: declaring a deviation no longer carries on to the commit by itself.
 
 - **Local decision — `plan-exec` continues.** A class or method name; a local helper; internal code layout; imports; a choice between equivalent APIs already allowed; a fix needed to compile; a minor refactor that does not move the journey; one extra focused test for a risk found while implementing. Declares **no signal** — the gate is not raised — and is recorded in `DECISION` only when it is not obvious.
-- **Composable decision — a note is registered and execution continues.** The change amends how the promise is met without changing who promised it. It is the only exit that writes a **decision note**, and it is available **only** when all four closures hold (below). The spec and the plan stay byte-exact.
+- **Composable decision — a note is registered and execution continues.** The change amends how the promise is met without changing who promised it. It is the only exit that writes a **decision note**, and it is available **only** when all four closures hold (below). The spec and the plan stay byte-exact. A **standalone** plan has no chain to add a note to: its decision stays in the run's trace and you write it into the session's `DECISION.md`.
 - **Structural deviation — stop and return to `plan-refine`.** Stop when the change touches: an input or output; an observable state; a relevant endpoint or public contract; the set of participating components or repositories; the phase order; the simulation boundary; the integration strategy; a material dependency; the main persistence mechanism; a phase already `validada`; the evidence needed to demonstrate the result. A decision that substantially expands or shrinks the work counts too.
-- **Functional change — return to `spec-refine`.** Stop when the change touches: the expected result; the functional scope; a business rule; an acceptance criterion; the actor or consumer; or a product decision.
+- **Functional change — return to `spec-refine`.** Stop when the **promise of the product** moves: the expected result; the functional scope; a business rule; the outcome an acceptance criterion states; the actor or consumer; a product decision. A technical divergence that leaves the promise intact never comes back here — its first exit is `Registrar la decisión y seguir`.
+
+> **How an affirmation is addressed:** a decision note names the criteria it amends as `S{NNN}/AC-nn` — `NNN` from the spec file's number, `AC-nn` the label the criterion carries in the spec's checklist. The CLI **derives** that id from the label plus the file number, so the readable form the spec template writes is already addressable (a criterion that spells the full id is read the same way, never counted twice). A note amending a criterion the spec does not state **at all** is refused with `CONTRACT_ASSERTION_ABSENT`, and the exit is the spec stating it (`spec-refine`), never a second spelling of the id here.
 
 **Eligibility is closure, never size.** The composable exit opens only when the four close: the
 divergence stays in the **same functional lineage**; its **intent is settled**, so nothing further has
@@ -178,7 +180,7 @@ erases an earlier one.
 | Add a participating repository | stops | — | yes | — |
 | Move the simulation to another boundary | stops | — | yes | — |
 | Change the phase order | stops | — | yes | — |
-| Add a functional rule · change an acceptance criterion | stops | — | — | yes |
+| Add a functional rule · move the outcome a criterion promises | stops | — | — | yes |
 | Does not compose against this lineage at all | stops | — | — | a spec of its own |
 
 ## Delta 2 — Git policy: **safe branch + proposed commits**
@@ -201,7 +203,7 @@ adds nothing of its own beyond running on a verified branch and never
   order, then the justified checks and cross-cutting validations. `isolated` runs the same stack for
   its single phase.
 - Each added test is re-weighed at the closing review gate ([`../CODE-POLICIES.md`](../CODE-POLICIES.md) § *Closing review gate* → *Test-value lens*, tag `overtest`): over-testing is a **finding to fix or justify**, never an automatic rejection.
-- Also run the plan's `## Validations` (cross-cutting rules and constraints) + the Final behavior block of `## Solution` (legacy plans: the `## Final behavior` section) + the spec's acceptance/success criteria (its `## Scenarios`, if present, are ready-made test cases: GIVEN=arrange · WHEN=act · THEN=assert).
+- Also run the plan's `## Validations` (cross-cutting rules and constraints) + the Final behavior block of `## Solution` (legacy plans: the `## Final behavior` section). **What execution runs is the PLAN's evidence, never the spec's prose:** `plan-new` already derived those validations from the spec's acceptance criteria and its `## Scenarios`, so the spec is confirmed functionally **through** them. A criterion no validation covers is a gap of the plan, not a test to improvise here.
 - A validation that **runs and fails** → back into the phase (gap): no advancing, no `validada`.
 
 - **SQL delivery**: validate the migration's behavior against a fixture or ephemeral database in the acquired checkout. The forward/rollback script is delivered through `SCRIPTS.sql` and `export-scripts`; a real application is an optional handoff and never keeps a phase or the plan open.

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

@@ -1,10 +1,10 @@
 ---
 name: plan-new-loop
 description: >-
-  Generates an executable plan (docs/plans/PPP-plan-<slug>.md) from a spec.
-  Heir of CHASSIS: phases are verifiable states; research maps impact and
-  gaps; UI design roots are reused or promoted and pinned. Suggests
-  spec-refine first when needed. Started by /w:plan-new; resumable.
+  Generates an executable plan (docs/plans/PPP-plan-<slug>.md) from a spec, or
+  standalone from the conversation. Heir of CHASSIS: phases are verifiable
+  states; research maps impact and gaps; UI design roots are reused or
+  promoted and pinned. Started by /w:plan-new; resumable.
 ---
 
 # plan-new-loop
@@ -21,14 +21,14 @@ PLAN
 `/w:plan-new` — **resumable** (same chassis mechanism, keyed off CHECKPOINT).
 
 ## Reads
-`docs/specs/NNN-spec-*.md` (glob or argument path). Readiness comes from frontmatter `status`, never the filename; an unrefined spec only suggests [`PLAN-INPUT`](../../modules/PLAN-INPUT.md)'s refine path. Questions routed to `PLAN` remain input to this loop.
+`docs/specs/NNN-spec-*.md` (glob or argument path). Readiness comes from frontmatter `status`, never the filename; an unrefined spec only soft-suggests a refine ([`PLAN-INPUT`](../../modules/PLAN-INPUT.md)). Questions routed to `PLAN` remain input to this loop.
 
 ## Writes
 `docs/plans/PPP-plan-<slug>.md` (`generate`; overwrite needs confirmation), or sibling plans after an accepted split (§ *Split gate (multi-plan)*). With UI it also publishes the scoped design revision in `docs/designs/`; it never graduates/exports anything else to `docs/` — that is separate `export-*` work.
 
-> **Naming:** [`PLAN-INPUT`](../../modules/PLAN-INPUT.md) § *Numbering* claims `PPP` for its run; only its owner fills it and an unpublished close frees it. Plans glob as `docs/plans/PPP-plan-*.md`.
+> **Naming:** [`PLAN-INPUT`](../../modules/PLAN-INPUT.md) § *Numbering* claims `PPP` for its run; only its owner fills it and an unpublished close frees it.
 
-> **Adoption (mode 4):** the command transcribes an externally-built plan once into Delta 1, records `## Origin`, then `plan-refine` closes schema gaps. See [`PLAN-INPUT`](../../modules/PLAN-INPUT.md).
+> **Adoption (mode 4):** an external plan is transcribed once into Delta 1 with its `## Origin`; `plan-refine` closes the schema gaps.
 
 ## Inherits
 
@@ -36,15 +36,15 @@ Read **[`../CHASSIS.md`](../CHASSIS.md)** — the loop's **full engine** — **a
 
 ## Internal sessions — PLAN-new instance
 
-Full doctrine in the chassis (§ *Internal sessions* + *Numbering*). This loop's instance:
+Full doctrine in the chassis (§ *Internal sessions* + *Numbering*):
 
 | Session | When | Artifacts | Role |
 |---|---|---|---|
-| **plan session** `NNN-<slug>-plan-new/` | when the loop starts (or resumes) | `SESSION.md` · `CHECKPOINT.md` (· `BACKLOG.md` only if something is deferred) | Owns the run. Type = `refine`; descriptor `<slug>-plan-new` (the `<slug>` comes from the input spec). |
+| **plan session** `NNN-<slug>-plan-new/` | when the loop starts (or resumes) | `SESSION.md` · `CHECKPOINT.md` (· `BACKLOG.md` only if something is deferred) | Owns the run. Type = `refine`; descriptor `<slug>-plan-new`. |
 
-## Delta 1 — Deliverable: the RICH PLAN (`PPP-plan-<slug>.md`)
+## Delta 1 — Deliverable: the RICH PLAN
 
-The plan keeps technical detail and roadmap inline:
+Technical detail and roadmap stay inline:
 
 ```markdown
 # Plan PPP — <slug>
@@ -59,16 +59,23 @@ The plan keeps technical detail and roadmap inline:
 ## Dependencies        docs · sources · DBs · sessions · inter-plan order (opt.)
 ## Design references   the baselines this plan's roots pin (opt. — only with UI)
 ## Tasks               `### Fn` blocks: the ONLY source of phases (core)
-## Execution batches   complete phase partition; contract in PLAN-EXECUTION-BATCHES (core)
-## Validations         cross-cutting validations and constraints (core)
+## Execution batches   complete phase partition (core)
+## Validations         cross-cutting rules + the evidence derived from the spec (core)
 ## Risks / impact      technical risks and impacts (opt.)
 ## Assumptions         delta over the spec only (opt.)
 ## Open questions      pending; core when any exist; OMIT the section when empty
 ```
 
 Core sections always appear; optional ones only when warranted. Legacy readers tolerate the old
-separate sections. New plans never write them. The exec session has no `TECHNICAL-NOTE` or own
-`TASKS`: detail and progress live in this plan.
+separate sections, which new plans never write.
+
+> **Header, seal and evidence.** A plan born from the conversation carries
+> `> Standalone: <origen> · generated by plan-new-loop` instead of `> Derived from …` (fixed label, free
+> prose): it seals no baseline and its deviations go to the session, never to a contract note. With a
+> spec, the `> Baseline:` the CLI seals is a **functional** digest of it: an editorial edit leaves this
+> plan aligned, and a seal still reading one as divergent is re-sealed (`aw reseal`: `prepare` → `apply
+> --approval`, or a re-publication), never redesigned. `## Validations` **derives** from the spec's
+> acceptance criteria and `## Scenarios` — tests, evidence and commands live here, outcomes there.
 
 Batch syntax, inference and runtime semantics are defined once in
 [`PLAN-EXECUTION-BATCHES`](../../modules/PLAN-EXECUTION-BATCHES.md).
@@ -76,7 +83,6 @@ Batch syntax, inference and runtime semantics are defined once in
 ## Phase contract (canonical)
 
 A `### Fn` block is a **verifiable state of the system**, never a list of layers, files or classes.
-This is the single contract; the other PLAN loops reference it.
 
 ```markdown
 ### F1 — <result-oriented name>
@@ -91,13 +97,13 @@ This is the single contract; the other PLAN loops reference it.
 ```
 
 **Required**: `Resultado` · `Trabajo` · `Validación de fase` · `Condición de salida` · the state
-line · `Fuentes`. Every task declares `_(fuentes: …)_`; task sources are a phase subset and either
-`workspace` or an exact `AGENTS.md > Fuentes` alias. `Impacted` never substitutes them. **Conditional**: `Estado inicial` when unclear · `Recorrido afectado` for a distributed
+line · `Fuentes`. Every task declares `_(fuentes: …)_`, a phase subset (`workspace` or an exact
+`AGENTS.md > Fuentes` alias); `Impacted` never substitutes them. **Conditional**: `Estado inicial` when unclear · `Recorrido afectado` for a distributed
 change · `Dependencias` when direct sequence is insufficient · `Límite de simulación` (**only** when temporary behavior exists) · `Diferido` when work was consciously excluded.
 **A new phase never writes an empty conditional block.**
 
-**Checkout is the only closing surface.** Proof is a local command, fixture, ephemeral DB or checkout
-inspection. A deployed host, product or remote read is research or non-blocking `Handoff operativo`, never phase closure.
+**Checkout is the only closing surface**: proof is a local command, fixture, ephemeral DB or checkout
+inspection — a deployed host, product or remote read is research or a non-blocking `Handoff operativo`.
 
 **Phase state = machine state.** One bare `> Estado: <value>` line uses `pendiente` | `en ejecución`
 | `bloqueada` | `validada`. It is updated in place and counted
@@ -115,18 +121,18 @@ closure is `final_validation_pending`.
 
 **Granularity is semantic, not mechanical.** A phase leaves a demonstrable state. A task is a
 coherent purpose and may touch many files; an edit operation is a **micro step**, never a plan
-entry. `XS–S` informs risk and scope but does not force mechanical splitting.
+entry. Size labels inform risk and scope; they never force a mechanical split.
 
 ## Delta 2 — Gap taxonomy (of "plan")
 
-Replaces the spec gap taxonomy with a planning-oriented one:
+Replaces the spec taxonomy with a planning one:
 
 | Gap | Signal | Resolved by |
 |---|---|---|
 | Approach/Solution undefined | the how is vague | research / human |
 | Components unidentified | FE/BE/DB impact unknown | **research** (maps the code) |
 | AS-IS wiring unknown | current state unknown | **research** |
-| Journey unmapped | the observable contract, the participating components or the repo/process boundaries are unknown — the phases cannot be ordered | **research** |
+| Journey unmapped | the observable contract, the participating components or the repo/process boundaries are unknown, so the phases cannot be ordered | **research** |
 | Phase without a state | a `### Fn` mixes unrelated functional states, or nothing can be validated until the very end | the AI re-shapes it by state (**human** confirms an order change) |
 | Plan splittable | independently deliverable tranches — different moments/priorities, no shared deps/risk | **human consents** → split (see *Split gate (multi-plan)*) |
 | Task named as an edit | the name states an edit operation ("create class X", "add method Y") instead of a purpose | the AI re-states it by purpose |
@@ -134,13 +140,13 @@ Replaces the spec gap taxonomy with a planning-oriented one:
 | Simulation without lifecycle | temporary behavior exists with no phase that displaces it and no phase that retires it | the AI derives both / **human** |
 | Phase without evidence | the block declares no `Validación de fase` | the AI derives it from the criteria / **human** |
 | Invalid execution batches | phases are missing/duplicated or cross an ineligible continuous boundary | the AI re-infers the maximal partition |
-| Over-engineered solution | approach heavier than the criteria need — needless abstraction/layer/dependency, or a phase/task not required to meet the spec (chassis § *Minimality*) | AI proposes the lighter path + **human** confirms (**probe** if "lighter works" is a runnable doubt) |
+| Over-engineered solution | approach heavier than the criteria need — needless abstraction/layer/dependency, or a phase/task the spec does not require (chassis § *Minimality*) | AI proposes the lighter path + **human** confirms (**probe** if "lighter works" is a runnable doubt) |
 | Missing deps | order unclear | research / human |
-| Spec criteria uncovered | tasks don't trace to acceptance criteria | the AI derives + human confirms |
+| Spec criteria uncovered | no task or evidence traces to a criterion | the AI derives + human confirms |
 | Unaddressed risks | technical risks unmitigated/undeclared | human / **probe** (Delta 5) |
-| UI without design *(if it applies)* | the plan includes UI (FE/screens in `Impacted`, `## Design references` in the spec, or UI tasks) and pins no exact root, or its roots are not `handoff` | **`design`** (promote the closure, pin the roots — reusing an already valid compact handoff instead of re-promoting it) |
+| UI without design *(if it applies)* | the plan includes UI (FE/screens in `Impacted`, `## Design references` in the spec, or UI tasks) and pins no exact root, or its roots are not `handoff` | **`design`** (promote the closure, pin the roots — reusing a valid compact handoff instead of re-promoting it) |
 
-> **Author the Solution the laziest-that-works way** (chassis § *Minimality*, generative side): reuse what the codebase/stdlib/platform already provides before proposing new abstractions, layers or dependencies — the coherence gate then only *confirms* minimality, never repairs over-engineering after the fact.
+> **Author the Solution the laziest-that-works way** (chassis § *Minimality*, generative side): reuse what the codebase/stdlib/platform already provides before adding abstractions, layers or dependencies — the gate then *confirms* minimality instead of repairing over-engineering.
 
 ## Delta 3 — What research investigates here
 
@@ -162,14 +168,14 @@ plan-new-loop(spec):
     gaps = detect_gaps(work)  (Delta 2 taxonomy)  minus the exhausted ones
     if gaps == ∅: break
     batch ≤3 → seed CHECKPOINT.Pending/Next → resolve each gap:
-      research · human (structured-choice) · probe · design (reuse valid handoff or promote missing closure + pin roots)
+      research · human (structured-choice) · probe · design (reuse a valid handoff, or promote + pin roots)
     integrate + update CHECKPOINT
   coherence gate (read-only) = Success criteria green:
-    - every spec criterion traces to a phase/task (split: exactly one sibling)
+    - every spec criterion traces to a phase/task + evidence (`## Validations`/`Validación de fase`) (split: exactly one sibling)
     - the Final behavior block of ## Solution covers the criteria
     - every ### Fn leaves a verifiable state with its own exit condition — never a list of layers or files
     - the order allows early integration · deps without cycles · Impacted consistent with Solution
-    - ONLY when the change carries simulation, its displacement and retirement are owned
+    - only when the change carries simulation, its displacement and retirement are owned
     - every phase declares primary evidence; layer tests are justified
     - Execution batches partitions every phase once and crosses only eligible boundaries
     - resumable between units and within one through states/checkboxes
@@ -177,25 +183,24 @@ plan-new-loop(spec):
     - (UI) every screen/UI task pins an exact root against a declared baseline · that closure is handoff · nothing outside it was promoted
     whatever fails → comes back as a gap
   hand the CLI the exact bytes of the plan — and of the siblings, if the split was accepted
-  the CLI seals them into ONE proposal and shows its preview: destination, weight, what it replaces
+  the CLI seals them into ONE proposal and previews it: destination, weight, what it replaces
     structured_choice(content: [Aprobar y guardar, Refinar], flow: [Compactar, Cerrar])
-    Aprobar y guardar → the CLI writes every file of the preview, together or not at all
-    Refinar          → nothing is written and the generation stays open
+    Aprobar y guardar → every file of the preview is written, together or not at all
+    Refinar           → nothing is written and the generation stays open
 finalize: CHECKPOINT persisted (+ BACKLOG only if something is deferred) + close session + report
 ```
 
 ## Convergence / exit
 
-- **No material gaps** → **coherence gate** (the *Sequence* checklist; the PLAN-new instance of the chassis convergence gate). Criterion→task traceability is a **checked invariant**, never a separate section.
-- **The gate judges functional states, not size.** Each phase needs an exit condition, evidence and,
-  **only when the change carries one**, its simulation lifecycle.
-- Passes → the save confirmation and, only after it, the write (confirmed again if the document
-  exists) → `finalize`. On the split branch the same step writes the N siblings.
+- **No material gaps** → **coherence gate** (the *Sequence* checklist). Criterion→task traceability is a **checked invariant**, never a separate section, and it runs one way: the PLAN covers the SPEC, never the reverse.
+- **The gate judges functional states, not size.**
+- Passes → the save confirmation and only then the write (confirmed again if the document exists) →
+  `finalize`. The split branch writes the N siblings in that same step.
 
-> **When the gate is evaluated, when the offer appears and with what alternatives, is not this document's call:** the deterministic steps below are decided by the CLI (`aw flow advance`), not by this document. The *Sequence* above stays as the loop's shape; it is not its scheduler.
-- `Cerrar` at any time → `finalize` (persists `CHECKPOINT`; `BACKLOG` only if something is deferred; closes the session, reports).
+> **When the gate is evaluated, when the offer appears and with what alternatives, is not this document's call:** the deterministic steps below are decided by the CLI (`aw flow advance`), not by this document.
+- `Cerrar` at any time → `finalize` (persists `CHECKPOINT`, closes the session, reports).
 
-> **After generating:** run `plan-exec`; use optional `plan-refine` when the structure changes first.
+> **After generating:** run `plan-exec` (`plan-refine` first only if the structure changes).
 
 ## Conditional modules
 

package/skills/w/loops/plan-refine-loop/LOOP.md

@@ -90,9 +90,9 @@ Reuses plan-new-loop's gap taxonomy **in full** ([`plan-new-loop`](../plan-new-l
 
 | Gap | Signal | Resolved by |
 |---|---|---|
-| Plan↔spec drift | the spec was re-refined and the plan fell out of line | **research** (re-reads the spec) / **human** |
+| Plan↔spec drift | the spec changed **functionally** (requirement, scope, criteria, scenarios, behavioral changes) and the plan fell out of line — an editorial edit of the spec is not drift: a `> Baseline:` that still reads one as divergent is closed by **re-sealing** (`aw reseal`, or the re-publication of the plan this loop's own save performs), never by a redesign, and the run does not converge leaving it divergent | **research** (re-reads the spec) / **human** |
 
-> **Spec-less degradation (hand-written / adopted plans).** When the plan has **no source spec** (`## Origin` = adopted / hand-written), the spec-anchored checks **degrade gracefully**: "spec criteria uncovered" and "plan↔spec drift" do **not** apply — criterion→task traceability anchors to the plan's **own** Final behavior block (in `## Solution`) / `## Validations` instead. The rest of the taxonomy (phase shape, simulation, evidence, deps, Impacted↔Solution, UI→SPEC) applies unchanged. Normalizing an adopted plan to the full Delta 1 schema **is** this loop's job (missing `(core)` sections are gaps).
+> **A spec-less plan is a first-class mode (standalone / hand-written / adopted).** When the plan has **no source spec** (`> Standalone:`, or `## Origin` = adopted / hand-written), the spec-anchored checks do not apply: "spec criteria uncovered" and "plan↔spec drift" are out, and criterion→task traceability anchors to the plan's **own** Final behavior block (in `## Solution`) / `## Validations` instead. The rest of the taxonomy (phase shape, simulation, evidence, deps, Impacted↔Solution, UI→SPEC) applies unchanged. Normalizing an adopted plan to the full Delta 1 schema **is** this loop's job (missing `(core)` sections are gaps).
 
 > **Adjust the Solution the laziest-that-works way** (chassis § *Minimality*, generative side): reuse what already exists before adding abstractions, layers or dependencies — the coherence gate only *confirms* minimality, and a re-refine is a chance to *remove* over-building, not add it.
 
@@ -119,7 +119,7 @@ Each phase carries proof of behavior, not of structure. Three levels, **chosen**
 2. **Focused proofs** — where a layer owns rules, a relevant transformation, error handling, persistence, transactions, temporal logic or an external integration.
 3. **Risk proofs** — security, concurrency, idempotency, retries, known regressions, plausible high-impact failures.
 
-The primary proof lives **inside its `### Fn` block** (`Validación de fase`); `## Validations` keeps the cross-cutting rules and constraints. A simulation gets only the minimum proof that demonstrates the wiring — no suite is built around what the next phase retires.
+The primary proof lives **inside its `### Fn` block** (`Validación de fase`); `## Validations` keeps the cross-cutting rules and the evidence derived from the spec's criteria and `## Scenarios`. A simulation gets only the minimum proof that demonstrates the wiring.
 
 > **Necessity gate** (design criterion, not a record to keep): what behavior does the test demonstrate, what unique failure would it catch, is that already demonstrated elsewhere, does it target a stable boundary or an internal detail, does the layer own logic or risk, is it still worth keeping once the simulation is gone? No clear answer → it is not planned. Whatever slips through and only mirrors structure is flagged `overtest` by execution's closing review gate.
 
@@ -158,7 +158,7 @@ plan-refine-loop(plan):
     integrate + update CHECKPOINT                              # artifact-first cycle
   executability gate (read-only) = Success criteria green:
     - contract · journey · phases · source boundary · simulation · evidence · execution batches · resumability (§ Executability gate)
-    - plan-new checklist (criterion→task · Final behavior block of Solution · deps · Impacted↔Solution · UI→exact roots · minimality)
+    - plan-new checklist (criterion→task+evidence · Final behavior block of Solution · deps · Impacted↔Solution · UI→exact roots · minimality)
       # spec-less plan (adopted/hand-written): criteria anchor to the plan's own Final behavior block/Validations (see Delta 2)
     - re-refine's own check: the plan is REALIGNED with what changed
     whatever fails → comes back as a gap

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

@@ -34,7 +34,7 @@ QUICK
 
 ## Internal session
 
-- **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.
+- **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). **Exception:** an entry-gate escalation to SPEC creates no quick session — the run never comes to exist and the session is the `spec-refine-loop` one.
 
 ## Inherits
 
@@ -44,35 +44,32 @@ Read **[`../CHASSIS.md`](../CHASSIS.md)** — the loop's **full engine** — **a
 
 `git` · `sql` (DB rule) · `research` (inline). Resolved via `.workflow/skills.toml`.
 
-> **Ambient conventions (not roles):** code/testing/writing standards and `creating-tools` are standalone skills the host auto-discovers by `description` — Workline neither binds nor depends on them. Full doctrine: [../../roles/README.md](../../roles/README.md).
-
 ## QUICK delta — minimal ceremony
 
-> **Directed tranche:** the deterministic steps below are decided by the CLI (`aw flow advance`), not by this document — it names the boundary in force, its alternatives, and the exact invocation when something has to run outside. What stays here is the *why*, plus every step that is judgment or preference.
+> **Directed tranche:** the deterministic steps below are decided by the CLI (`aw flow advance`), not by this document — it names the boundary in force, its alternatives and the exact invocation when something runs outside. What stays here is the *why*, and every step that is judgment.
 
 - **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`; fixture/ephemeral checks are local proof and any remote read is research context, never closure.
+- **Fix preview, before executing**: declare the fix you are about to make — files to touch, intent, expected shape of the diff. It is **proportional**: one line for something trivial; approach, files and risks for something complex. Above the same signal threshold that fires the entry size gate (below), a person approves it (`Ejecutar tal cual` · `Ajustar el enfoque` · `Escalar a spec` → *Mid-loop escalation*). **Below the threshold there is no human stop**: the preview stays declared in the session and the task executes.
 - **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): a quick that should have been a spec costs more than the ceremony it saved, so the size of the objective is judged **before** anything exists. Your part is recognizing the signals; the threshold, the question and its options are the CLI's. A signal already resolved by *adopted context* is **not** a signal (chassis § *Adopted context*). A **resume** of an existing quick never re-fires it.
+- **Entry SIZE GATE** (before creating the session): a quick that should have been a spec costs more than the ceremony it saved, so the size of the objective is judged **before** anything exists. Your part is recognizing the signals; the threshold, its anti-duplicate search, the question and its options are the CLI's. A signal already resolved by *adopted context* is **not** a signal (chassis § *Adopted context*). A **resume** of an existing quick never re-fires it.
   - **`Recortar alcance`**, if chosen: propose the **sub-task that DOES fit** a quick (`SESSION.Objective` = the sub-task; the original prompt goes into `## Origin`) and defer the rest to `BACKLOG` ("trimmed at the gate — may warrant its own spec, `/w:spec-new`").
   - **`Cambiar a SPEC`**, if chosen: **no quick session is created** — run the *Live transition to SPEC* (next bullet).
 - **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 --publish spec-<slug>.md` with the finished draft on stdin (number assigned and document written in one atomic act, no reservation left), schema, single-pass **NO RESEARCH** — its bounded reconnaissance does **not** re-fire (this run's context arrives adopted). `## Origin` = "escalated from `/w:quick`" + the original prompt (+ the origin quick session if it exists). The draft is born `status: draft`: only the SPEC gate promotes it to `ready-for-plan`.
+  1. **Materialize the draft** via the [`../../commands/spec-new.md`](../../commands/spec-new.md) procedure: `aw next-number docs/specs --publish spec-<slug>.md` with the finished draft on stdin (one atomic act: number assigned, document written, no reservation left), schema, single-pass **NO RESEARCH** — its bounded reconnaissance does **not** re-fire (this run's context arrives adopted). `## Origin` = "escalated from `/w:quick`" + the original prompt (+ the origin quick session if it exists). The draft is born `status: draft`: only the SPEC gate promotes it to `ready-for-plan`.
   2. **Load and execute** [`../spec-refine-loop/LOOP.md`](../spec-refine-loop/LOOP.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, declare the signals again — the CLI applies the same threshold and, if it fires, asks. If the user accepts moving up:
-  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).
+  1. **Any 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 of *Safe git*).
+  2. The quick session goes to `finalize` with the **pointer** in `BACKLOG`: to **PLAN** → "escalated to `docs/plans/PPP` — resume there" (**deferred**: seed + pointer, no live entry); to **SPEC** → "escalated to `docs/specs/NNN` — **continued live** (session `NNN-<slug>-spec-refine`)", or "escalated at the preview — continue in `/w:spec-new`" when no code and no `NNN` exist yet.
+  3. The artifacts (`DECISION`, `SCRIPTS.sql`) **stay in the quick session** as referenceable context, 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.
 
 ## Sequence
 
 ```
 quick-loop(prompt):
-  # The CLI drives the entry gate, its anti-duplicate search and the session, and
-  # stops at each boundary it cannot decide; it verifies the seeding afterwards.
   # `Cambiar a SPEC` → live transition (see delta): draft (spec-new procedure) +
   #                    load and execute ../spec-refine-loop/LOOP.md → END (no quick session)
   if the conversation already established analysis/conclusions →                 # adopted context (chassis)
@@ -80,6 +77,8 @@ quick-loop(prompt):
   author SESSION.Success criteria = the deliverable's check  # test(s) if code · short RATIFIED rubric if analysis/design
   work the task (minimal loop):
     if it edits code → verify each source's expected branch (`aw check-branch`); mismatch → pause + resolve
+    declare the fix preview (files · intent · expected diff), proportional to the task
+      above the gate's threshold → the CLI asks for approval; below it, nothing stops
     produce the deliverable: edit code (minimal change) OR author the analysis/design
     if fixture/ephemeral DB check → run it from the checkout + capture its proof
     if DB change (DDL/DML) → SCRIPTS.sql (session artifact, DO NOT execute)
@@ -102,9 +101,9 @@ finalize: CHECKPOINT (AFTER: Pending→Completed) + BACKLOG (only if something i
 
 - 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).
+- **No export**: nothing goes to `docs/` (§ *Writes*); escalating is the only way up.
 
-> QUICK's *convergence gate* is **proportional verification-first**: a **short** `Success criteria` declared at start (not the *absence* of a checklist — its minimal version). The CLI evaluates it, and it evaluates the **real output** of running those criteria — a claim that they passed is not a result.
+> QUICK's *convergence gate* is that same **proportional verification-first**: a **short** `Success criteria` declared at start — its minimal version, never the *absence* of a checklist. The CLI evaluates the **real output** of running those criteria; a claim that they passed is not a result.
 
 ## Conditional modules
 

package/skills/w/loops/spec-refine-loop/LOOP.md

@@ -103,7 +103,8 @@ status: ready-for-plan    ← stamped on Guardar (vocabulary: draft | refining |
 ## Behavioral changes     (opt. — behavior added / modified / removed / preserved; only
                            when existing behavior is touched — greenfield omits it)
 ## Scope                  (clear In / Out)
-## Acceptance criteria    (testable, - [ ]; EARS style; behavioral ones expand in ## Scenarios)
+## Acceptance criteria    (functional, observable, product-level; - [ ] AC-nn; EARS style;
+                           behavioral ones expand in ## Scenarios)
 ## Scenarios              (opt. — GIVEN/WHEN/THEN/AND blocks; each traces to ≥1 criterion.
                            Only when it adds GIVEN setup or edge semantics the criterion
                            does not capture — NEVER a 1:1 restatement of a criterion)
@@ -124,7 +125,7 @@ The choices a reader needs in order to interpret the contract, each with its why
 
 > **`## Open questions` carries destinations.** Each entry states why it is still open, whether it blocks `ready-for-plan`, and where it goes: `PLAN`, the user, later research, another spec. A question may survive convergence **only** if it does not force `PLAN` to invent behavior.
 
-> **Acceptance criteria = static testable criteria** (the "what"): plan-exec validates them, but progress is tracked in the PLAN (its Tasks), never by ticking these `- [ ]` in the spec; the spec never mutates by execution, only by a re-refine.
+> **Acceptance criteria = functional, observable outcomes at product level**, each labeled `AC-nn` — the label is what makes it addressable, and only under a `##` heading: the seal reads H2 only, so a nested `### Acceptance criteria` neither seals nor is addressable. A decision note amends it as `S{NNN}/AC-nn`, with `S{NNN}` derived from the spec's file number. A note naming a criterion the spec does not state is refused (`CONTRACT_ASSERTION_ABSENT`). **The verification strategy — tests, evidence, commands — is the PLAN's** (its `## Validations`): here goes the outcome, there goes how it is proven. Progress is tracked in the PLAN (its Tasks), never by ticking these `- [ ]` in the spec; the spec never mutates by execution, only by a re-refine.
 
 ## Who decides what
 
@@ -139,7 +140,8 @@ The choices a reader needs in order to interpret the contract, each with its why
 | Vague requirement | the what/why is ambiguous | **human** | SPEC — blocking |
 | Blurry scope | `Out` missing, or In/Out overlap | **human** | SPEC — blocking |
 | Business rule undefined | which condition decides an outcome | **research** or **human** | SPEC — blocking |
-| Untestable criteria | acceptance not verifiable | **human** (derive + confirm — often as a `### Scenario`) | SPEC — blocking |
+| Unverifiable criterion | the outcome is not observable at product level | **human** (make the OUTCOME observable — often as a `### Scenario`) | SPEC — blocking |
+| Test-shaped criterion | the criterion prescribes evidence or test mechanics instead of an outcome (naming the product's OWN command or flag is not test mechanics) | the AI proposes the functional rewrite + **human** confirms | SPEC (the mechanics travel to PLAN) |
 | Internal contradiction | sections contradict each other | **human** | SPEC — blocking |
 | Current behavior unknown | the baseline the change rests on is missing | **research** (inline) | SPEC → `Context` / `Behavioral changes` |
 | Incomplete context | systems/components unidentified | **research** | SPEC |
@@ -223,6 +225,8 @@ finalize:
 - **No blocking gaps** → **ready-for-plan gate** (read-only) = **`Success criteria` green** (*verification-first*; the SPEC instance of the chassis convergence gate). The checklist:
   - the requested outcome is understandable, the relevant current behavior is established, and the behavior change is described whenever existing behavior is touched;
   - `Scope` separates In from Out; every acceptance criterion traces to the `Requirement`; scenarios trace to ≥1 criterion and add GIVEN setup or edge semantics beyond it, without contradicting `Scope` (a 1:1 restatement is gold-plating: cut it);
+  - no criterion prescribes verification mechanics (test names, evidence, the commands that PROVE it) or an internal mechanism: that travels to `PLAN` with its destination declared — the product's own visible surface (a CLI's commands and flags, an API's endpoints, observable messages and formats) is behavior, not mechanics;
+  - every criterion carries its `AC-nn` label — what a decision note amends as `S{NNN}/AC-nn`; an unlabeled criterion is one no decision can address;
   - no material contradictions; the one-vs-many shape was validated at the *Change-shape gate*;
   - every **blocking** functional decision is resolved, and every remaining question carries its destination;
   - **Minimality** — no gold-plating: every criterion and scope item earns its place (chassis § *Minimality*); speculative scope is cut or deferred, and no technical solution was imposed that the requirement did not ask for;

package/skills/w/modules/COMPACTION.md

@@ -4,6 +4,6 @@ Loaded when the run is long enough that context pressure governs its pacing (sig
 
 `Compactar` is not only reactive: the loop **watches its own context pressure** and raises compaction itself. Recognizing that pressure is judgment — the host's signal where it exists (*compaction* capability in [`../harness/HARNESS.md`](../harness/HARNESS.md)), otherwise the **qualitative** question *"would a fresh reader need the CHECKPOINT to continue?"* at a boundary of an already-long run. Doctrine fixes **no numeric thresholds**: a number that means anything is a number about one host.
 
-> **Which mode runs, and whether the host can honour it, is not this document's call:** `aw checkpoint-write --can-pause` decides it from the `[compaction]` config (`mode` = `confirm` | `auto`), the host's binding and the session's state. `auto` needs a **non-interactive** mechanism and **degrades to `confirm`** without one; **CHECKPOINT before compacting** holds in every mode. What this document keeps is why: consent is never skipped where a person can be asked, and a compaction that fires before the checkpoint loses the thread it was meant to protect.
+> **Whether the host can honour it is not this document's call:** `aw checkpoint-write` writes the CHECKPOINT and **never holds the compaction back** — there is no configurable mode; an ambiguity degrades and parks a refuge checkpoint to adopt later. **CHECKPOINT before compacting** is the invariant. What this document keeps is why: consent lives in the `Compactar` control a person ratifies, and a compaction that fires before the checkpoint loses the thread it was meant to protect.
 
 > **`Compactar`** (the `flow` control) → write `CHECKPOINT.md` in the session (in-flight progress, remaining gaps, Q&A, `attempts`) → trigger the harness **compaction** (Claude Code: `/compact`; see [`../harness/HARNESS.md`](../harness/HARNESS.md)) → resume by reading the checkpoint.

package/skills/w/modules/PLAN-INPUT.md

@@ -6,10 +6,10 @@ Loaded when the input is not plainly a `ready-for-plan` spec (signal `input`).
 
 1. **Ready spec** (`docs/specs/NNN-spec-<slug>.md`, `status: ready-for-plan`) → proceed.
 2. **Spec not ready** (`draft`, `refining`, or no mark) → **soft-suggest** `/w:spec-refine`, never a block. `PLAN` questions remain input here.
-3. **Prompt** (no spec) → propose and normally launch `/w:spec-new`, then continue.
+3. **Prompt** (no spec) → **two exits**: (a) **spec first** — propose and launch `/w:spec-new`; the default when the request reads as a product wish; (b) **standalone plan** — planned straight from the conversation, its header carrying `> Standalone: <origen> · sesión NNN-<slug>` instead of `> Derived from …`.
 4. **External plan** (host, hand-written, another agent) → **adopt once, NO RESEARCH** at `docs/plans/PPP-plan-<slug>.md`. Normalize only supplied material; set `## Origin` to "adopted from <source>" + host/model/date; offer `/w:plan-refine` or `/w:plan-exec`. A matching Origin resumes; never overwrite a plan-doc.
 
-> **Mode 3 vs 4:** a prompt that *describes a wish* → SPEC (mode 3); content that *already is a plan* → adopt (mode 4).
+> **Mode 3 vs 4:** a prompt that *describes a wish* → mode 3 (spec first, or a standalone plan when the conversation already settled the how); content that *already is a plan* → adopt (mode 4).
 
 > Adoption is CLI-owned: the deterministic steps below are decided by the CLI (`aw flow advance`), not by this document.
 
@@ -23,7 +23,7 @@ Loaded when the input is not plainly a `ready-for-plan` spec (signal `input`).
 2. **No plan** → soft-suggest `/w:plan-new`; the user decides.
 3. **Returned by `plan-exec`** (unexecutable entry or structural deviation) → retain `validada` phases and redesign only pending work.
 
-> **Spec-less plans are legitimate input.** The coherence gate **degrades gracefully**: criteria trace to the plan's own Final behavior block instead of spec criteria, and the "spec criteria uncovered" gap does not apply.
+> **A spec-less plan is a FIRST-CLASS mode, not a defective plan** (`> Standalone:`, adopted or hand-written). Its contract is its own *Final behavior* block + `## Validations`, so the "spec criteria uncovered" gap does not apply. A marked plan seals no baseline and the board reports its own `standalone` mode, no unsealed notice: the mode here, not a defect. Its deviations register in the session's `DECISION.md` and the run continues — a contract note needs a spec.
 
 ## Numbering
 

package/skills/w/modules/PROMPT-CONTINUITY.md

@@ -4,7 +4,7 @@ Loaded when a bare prompt continues an existing work line (signal `resume`).
 
 ## Continuity across prompts (operating context)
 
-`quick` is where the **continuity rule** ([`../../SKILL.md`](../../SKILL.md) § *Operating context*) shows most clearly. Inside a workspace:
+`quick` is where the **continuity rule** ([`../SKILL.md`](../SKILL.md) § *Operating context*) shows most clearly. Inside a workspace:
 
 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`.