chore: promote next to main

.github/workflows/back-merge.yml

@@ -1,9 +1,11 @@
 name: Back-merge
 
 # After a release on main, sync main back into next so its changelog, manifest,
-# and version bumps do not drift. No conflict -> push next directly (the App is
-# an "always" bypass actor on next). Conflict -> open a PR for a human.
-# Any other failure -> open a tracking issue so the drift is never silent.
+# and version bumps do not drift. When next holds no unreleased work, realign it
+# onto main's hashes (force-push, the App is an "always" bypass actor on next)
+# so the rebase-promote hash drift cannot accumulate. When next has real work,
+# keep the merge. Conflict -> open a PR for a human. Any other failure -> open a
+# tracking issue so the drift is never silent.
 
 on:
   release:
@@ -40,7 +42,17 @@ jobs:
           git config user.email "aidd-bot[bot]@users.noreply.github.com"
           git fetch origin main
           if git merge --no-edit origin/main; then
-            git push origin next
+            # Promotes to main are rebase-merged, so main carries new commit
+            # hashes and next drifts even though the content matches. When the
+            # merge result is content-identical to main (next held no unreleased
+            # work), realign next onto main's clean hashes so the drift cannot
+            # accumulate into a giant conflicting promote later. Otherwise next
+            # has real unreleased work, so keep the merge and push normally.
+            if git diff --quiet origin/main HEAD; then
+              git push --force origin "origin/main:refs/heads/next"
+            else
+              git push origin next
+            fi
           else
             git merge --abort
             BRANCH="back-merge/main-to-next-${{ github.run_id }}"

README.md

@@ -13,9 +13,7 @@
 
 # AI-Driven Dev Framework
 
-### Vibe Coding for professional developers — focused on 100% quality on AI-generated code.
-
-<p><b>🇫🇷 The first French open-source framework for AI-driven development.</b></p>
+### A French framework for AI-Driven Developer to produce high code quality.
 
 <p>
   <!--counts:start--><kbd>7 plugins</kbd> · <kbd>40 skills</kbd> · <kbd>2 agents</kbd><!--counts:end--> · <kbd>MIT</kbd>
@@ -26,7 +24,7 @@
 [![CI](https://github.com/ai-driven-dev/framework/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/ai-driven-dev/framework/actions/workflows/ci.yml)
 [![Made in France](https://img.shields.io/badge/made%20in-France-0055A4?labelColor=EF4135)](https://www.ai-driven-dev.fr/)
 
-<p>🗺️ <a href="https://github.com/orgs/ai-driven-dev/projects/8/views/1"><b>Live roadmap</b></a> — what's shipping Now / Next / Later</p>
+<p>🗺️ <a href="https://github.com/orgs/ai-driven-dev/projects/8"><b>Live roadmap</b></a> — what's shipping Now / Next / Later</p>
 
 </div>
 
@@ -238,7 +236,7 @@ Task-oriented how-to sheets. **[Browse all recipes →](recipes/)**
 
 > ⭐ **Free & open-source (MIT), built by the AIDD community.** If AIDD saves you time, [**a star**](https://github.com/ai-driven-dev/framework/stargazers) genuinely helps the project grow and helps other developers find it.
 
-> Actively maintained — the [roadmap](https://github.com/orgs/ai-driven-dev/projects/8/views/1) is public; help shape what comes after.
+> Actively maintained — the [roadmap](https://github.com/orgs/ai-driven-dev/projects/8) is public; help shape what comes after.
 
 Got an idea or hit a bug? **[Open an issue](https://github.com/ai-driven-dev/framework/issues)** or **[start a discussion](https://github.com/ai-driven-dev/framework/discussions)**. For everything else, **[join the Discord](https://discord.gg/EWySJSpjWs)**.
 

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-1.md

@@ -0,0 +1,30 @@
+---
+status: pending
+---
+
+# Instruction: Root rule, behavior over instructions
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-context/skills/04-skill-generate/references/
+  ✏️ skill-authoring.md   # add the Steinberger rule (new R)
+```
+
+## Tasks to do
+
+### `1)` Add the behavior-over-instructions rule
+
+> Codify the pivot as an authoring rule every generator reads.
+
+1. Add a new `R` to `skill-authoring.md`: an action describes the behavior and the qualify-if bar, never a slot-fill checklist. A template section states what qualifies it and omits when nothing does.
+2. State the anti-slop consequence in one line: an empty slot is omitted, never invented.
+3. Keep it inside the existing R-list numbering and voice; no new file.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                                 |
+| ---- | ---------------------------------------------------------------------------------- |
+| 1    | `skill-authoring.md` carries a rule that says describe behavior + qualify-if/omit, and forbids inventing content for an empty section. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-2.md

@@ -0,0 +1,31 @@
+---
+status: pending
+---
+
+# Instruction: Gates single-home + SDLC assert step
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-dev/skills/00-sdlc/
+  ✏️ SKILL.md   # insert an assert step between implement and review
+```
+
+## Tasks to do
+
+### `1)` Chain assert in the orchestrator
+
+> The gate must run once gates leave the plan.
+
+1. Add an assert step to the `00-sdlc` action table, delegating to `aidd-dev:03-assert`, between `implement` and `review`.
+2. Update the run order and the iterate loop so a failed assert loops back to implement.
+3. Confirm no SDLC template or action restates build/test/typecheck commands; those stay in `coding-assertions.md`.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                        |
+| ---- | ------------------------------------------------------------------------- |
+| 1    | `00-sdlc` runs implement → assert → review; a failed assert returns to implement. |
+| 1    | No SDLC skill file lists a build or test command; the gate reads `coding-assertions.md`. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-3.md

@@ -0,0 +1,32 @@
+---
+status: pending
+---
+
+# Instruction: Spec done-when as observable conditions
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-pm/skills/04-spec/
+  ✏️ assets/spec-template.md   # done-when = observable condition, qualify-if guidance
+  ✏️ actions/01-build.md       # behavior, not slot-fill
+```
+
+## Tasks to do
+
+### `1)` Discipline done-when
+
+> One observable condition per line, no user-story scaffolding.
+
+1. Rewrite the Done-when block guidance: each item is an observable condition (what a user or system can be seen doing), not a command and not a feeling.
+2. Confirm the plan references the spec done-when rather than recopying it (contract owns it).
+3. Update `01-build.md` so it describes the qualify bar per section and omits an empty one, per the phase-1 rule.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                            |
+| ---- | ----------------------------------------------------------------------------- |
+| 1    | Done-when items read as observable conditions; the template shows no command as a done-when. |
+| 1    | `01-build.md` instructs qualify-if/omit, carrying no fill-every-slot wording. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-4.md

@@ -0,0 +1,43 @@
+---
+status: pending
+---
+
+# Instruction: Plan + phases anti-slop
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-dev/skills/01-plan/
+  ✏️ assets/plan-template.md    # decisions = magnitude, resources = URLs/files
+  ✏️ assets/phase-template.md   # wireframe omit-guard, acceptance = observable, drop header redirect
+  ✏️ actions/04-plan.md         # qualify-if/omit behavior
+  ✏️ actions/03-wireframe.md    # only when the phase has UI
+```
+
+## Tasks to do
+
+### `1)` Qualify each plan section
+
+> Every table earns its rows or omits.
+
+1. Decisions: qualify bar = "you would regret reversing it" (architecture magnitude). Small choices are omitted, not recorded.
+2. Resources: external URLs consulted, in the plan; modified files belong to the phase, not the plan resources table.
+3. Phase acceptance criteria: observable behavior only; a build/test command is a gate, never an acceptance criterion.
+
+### `2)` Trim the phase
+
+> Cut what no reader uses.
+
+1. Wireframe section: keep the `omit when no UI` guard and make `03-wireframe` run only for a UI phase.
+2. Drop the redundant "Part of plan.md" redirect if it carries no navigation value, or justify keeping it in one line.
+3. Rewrite `04-plan.md` to the qualify-if/omit behavior from phase 1.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                              |
+| ---- | ------------------------------------------------------------------------------- |
+| 1    | Templates state the qualify bar for decisions, resources, and acceptance criteria. |
+| 1    | Acceptance-criteria guidance forbids a bare command as a criterion.             |
+| 2    | A no-UI phase produces no Wireframe section; `03-wireframe` self-skips without UI. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/phase-5.md

@@ -0,0 +1,41 @@
+---
+status: pending
+---
+
+# Instruction: Review redesign, trace phases as checkboxes
+
+Part of [`plan.md`](./plan.md).
+
+## Architecture projection
+
+```txt
+plugins/aidd-dev/skills/05-review/
+  ✏️ assets/review-template.md      # phases as checkboxes, verification line, no prose/follow-up
+  ✏️ actions/02-review-functional.md # trace the plan's phases, not a free criterion table
+  ✏️ SKILL.md                        # point sections at the new template shape
+```
+
+## Tasks to do
+
+### `1)` Rebuild the review template
+
+> A skimmable gate a human reads in one pass.
+
+1. Structure the report around the plan's phases: one category per phase, each acceptance criterion a checked or unchecked box.
+2. End with a verification line: percent verified, the files checked, and a fix / not-applicable / fixed status per unchecked item.
+3. Delete the prose blocks and the Follow-up section; the verdict line and the boxes carry the signal.
+
+### `2)` Point the actions at it
+
+> The functional axis follows the plan.
+
+1. Rewrite `02-review-functional.md` to trace the plan's phases and their acceptance criteria, not an ad-hoc criterion list.
+2. Update `SKILL.md` section wording to match the new template.
+
+## Test acceptance criteria
+
+| Task | Acceptance criteria                                                                     |
+| ---- | -------------------------------------------------------------------------------------- |
+| 1    | `review.md` shows one category per plan phase with checked/unchecked boxes and a final verification line. |
+| 1    | The template carries no Follow-up section and no prose paragraph.                        |
+| 2    | `02-review-functional.md` traces the plan's phases; a review of a phased plan lists every phase. |

aidd_docs/plans/2026_07_01-sdlc-anti-slop/plan.md

@@ -0,0 +1,63 @@
+---
+objective: "SDLC artifacts stop emitting slop: every template section states what qualifies it and omits when nothing does, gates live only in /assert, the review traces the plan's phases as checkboxes."
+status: pending
+---
+
+# Plan: SDLC anti-slop hardening
+
+## Overview
+
+| Field      | Value                                                                                  |
+| ---------- | -------------------------------------------------------------------------------------- |
+| **Goal**   | Cut the telling-what-to-do, tighten the output contract, so artifacts stay skimmable.  |
+| **Source** | Brainstorm 2026-06-30 (Alex's SDLC run: weak decisions, fake acceptance criteria, useless wireframe, unreadable review). |
+
+## Pivot
+
+Two axes were conflated. Separate them:
+
+- **How the agent works** (process, steps) => loosen, cut. This is Steinberger: describe the behavior, not the steps.
+- **What it emits** (templates, assets) => constrain hard.
+
+"Cut more" means cut the instructions, not the structure. The root cause of every slop item: a template with empty slots that the agent fills anyway. Fix = each section states its qualify-if bar and omits when nothing meets it.
+
+## Phases
+
+| #   | Phase                                        | File                         |
+| --- | -------------------------------------------- | ---------------------------- |
+| 1   | Root rule: behavior over instructions        | [`phase-1.md`](./phase-1.md) |
+| 2   | Gates single-home + SDLC assert step         | [`phase-2.md`](./phase-2.md) |
+| 3   | Spec: done-when as observable conditions      | [`phase-3.md`](./phase-3.md) |
+| 4   | Plan + phases anti-slop                       | [`phase-4.md`](./phase-4.md) |
+| 5   | Review redesign: trace phases, checkboxes     | [`phase-5.md`](./phase-5.md) |
+
+## Resources
+
+| Source        | Verified                    |
+| ------------- | --------------------------- |
+| `plugins/aidd-context/skills/04-skill-generate/references/skill-authoring.md` | Rules live as R1..Rn here; every generator reads it. Home for the Steinberger rule. |
+| `plugins/aidd-dev/skills/03-assert/SKILL.md` | Already the gate: "returns a pass or fail verdict", fix-loop until green. Runs the project's coding assertions. |
+| `plugins/aidd-dev/skills/00-sdlc/SKILL.md` | Chains spec→plan→implement→review→ship. No assert step: gates would drop if stripped from the plan. |
+| `plugins/aidd-dev/skills/01-plan/assets/{plan,phase}-template.md` | Slot templates. `04-plan.md:17` already carries an omit idiom; phase wireframe carries `omit when no UI`. Inconsistent. |
+| `plugins/aidd-pm/skills/04-spec/assets/spec-template.md` | Done-when + optional-section suffix `(optional)` already present. |
+| `plugins/aidd-dev/skills/05-review/assets/review-template.md` | Prose + Follow-up section; functional axis traces criteria in a table, not the plan's phases. |
+| `aidd_docs/memory/coding-assertions.md` | Project's gate commands (build/test/typecheck) — the single home gates belong in. |
+
+## Decisions
+
+| Decision   | Why            |
+| ---------- | -------------- |
+| Steinberger rule lands in `skill-authoring.md`, not a new central "golden rules" doc | No golden-rules surface exists; every generator already reads this file, so the rule propagates for free. |
+| Gates leave the plan for `/assert` + `coding-assertions.md` | One home per fact; the plan becomes 100% behavioral, gates stay mechanical and single-sourced. |
+| `00-sdlc` gains an assert step between implement and review | Stripping gates from the plan drops them unless the orchestrator runs `/assert` explicitly. |
+| Reuse the existing `<!-- omit when ... -->` idiom for optional sections | The pattern already exists (phase wireframe); inventing HTML-template machinery would be churn. |
+
+## Spec done-when → phase coverage
+
+| Done-when (observable) | Phase |
+| ---------------------- | ----- |
+| A rule in `skill-authoring.md` states "describe behavior + qualify-if/omit, never slot-fill" | 1 |
+| `00-sdlc` runs `/assert` before review; no template restates build/test commands | 2 |
+| Spec done-when items are observable conditions, no user-story scaffolding required | 3 |
+| Plan decisions are magnitude-only; resources are URLs/files; wireframe omits without UI; no phase-header redirect | 4 |
+| `review.md` mirrors the plan's phases as checked/unchecked boxes, ends with a verification line, carries no prose dump or Follow-up | 5 |

docs/RELEASE.md

@@ -50,9 +50,11 @@ To force a package to a chosen version on the next cut, set `release-as` for it
 in `release-please-config.json` (deterministic, overrides any `Release-As:`
 commit footer). Remove the pin afterwards so automatic bumps resume.
 
-## Back-merge failures
-
-If the back-merge cannot push `next`, it opens an issue labelled
-`back-merge-failed`. Resync by opening a `main -> next` PR. The root cause is the
-bot app needing an `always` bypass on the `next` ruleset; align that and the
-back-merge runs unattended.
+## Back-merge and drift
+
+The back-merge runs unattended (the bot app has an `always` bypass on the `next`
+ruleset). After each release it either realigns `next` onto `main` (when `next`
+holds no unreleased work, the normal case) or keeps a merge (when it does), so
+the rebase-promote hash drift never accumulates. If it ever cannot push, it
+opens an issue labelled `back-merge-failed`; resync by opening a `main -> next`
+PR.

plugins/aidd-context/skills/04-skill-generate/references/skill-authoring.md

@@ -19,7 +19,7 @@ The contract every generated skill must satisfy. These rules govern the CLIENT s
 - **R6.** Zero duplication. One fact, one home. Actions cite a shared file via `@<path>` instead of restating it.
 - **R7.** `references/` = documents to READ and apply in place. `assets/` = files to COPY, INJECT, or fill in per run. A template, checklist, or form is an asset, not a reference, because each run instantiates it.
 - **R8.** Every action follows the action anatomy (below) and carries a `## Test`.
-- **R9.** Omit any optional section that would be empty. Never write a placeholder like `## External data` + `None.`.
+- **R9.** A section earns its content or is omitted. State each section's qualify bar and describe the behavior it captures, not a slot to fill. An entry that fails the bar is dropped, never invented to occupy the row. Never write `## External data` + `None.`, nor mint a decision, criterion, or resource just because the template offers it. A template's section set is closed: an instance fills or omits the defined sections and never adds, renames, or reorders one.
 - **R10.** Generated skills are English only (frontmatter, body, actions, references, assets), regardless of conversation language.
 - **R11.** One idea per sentence. Split a sentence that runs past one line. Exceptions: the single-line `description` and table rows.
 - **R12.** One file = one artifact. A reference or asset holds a single coherent thing: one checklist, one template, one criteria set. When a file accumulates several independently reusable artifacts, split them so each is cited and reused alone. Prefer this split over bundling, even when the combined file is short.

plugins/aidd-dev/agents/checker.md

@@ -15,7 +15,8 @@ You are the checker. Your job is to judge finished work against its validator an
 - Run the checklist on every code or diff, leaving no item unchecked.
 - Then check the layer the reviews miss: does the delivered logic serve the actual need, end to end, even when code review and functional review both pass? Name any gap between intent and result.
 - Demand command output or file evidence, never bare claims. Lean strict: a false alarm costs less than a missed defect.
-- Return your verdict, findings, and score to whoever invoked you. Hold yourself accountable for whatever you pass.
+- When a review skill fits the work, run it and let it write its report; that report is your deliverable and your judgment is what fills it. Never hand-write a parallel prose review beside it.
+- Return your verdict, findings, and score on top. Hold yourself accountable for whatever you pass.
 
 # Checklist
 

plugins/aidd-dev/skills/00-sdlc/SKILL.md

@@ -14,7 +14,7 @@ Take a request from idea to shipped code, delegating every step. Interactive by
 | --- | ----------- | ------------------------------------- | --------------------------------------- |
 | 01  | `spec`      | Consolidate sources into the contract | a spec capability                       |
 | 02  | `plan`      | Produce the plan file                 | self, via `aidd-dev:01-plan`            |
-| 03  | `implement` | Build the plan's code                 | `executor`, via `aidd-dev:02-implement` |
+| 03  | `implement` | Build the plan's code, gating on the assertions | `executor`, via `aidd-dev:02-implement` |
 | 04  | `review`    | Verdict `ship` or `iterate`           | `checker`, via `aidd-dev:05-review`     |
 | 05  | `ship`      | Open the change request               | a commit and change-request capability  |