agentplugged 1.2.0 → 1.4.0

package/dist/method/skills/review-story/SKILL.md

@@ -1,93 +1,65 @@
 ---
 name: review-story
-description: Review a story's pull request, or any change, independently with lenses the engine chooses and a judge in a fresh context, in one whole report. Run by the reviewers.
+description: Review a story's pull request, or any change, independently with lenses the engine chooses and a judge in a fresh context, in one report. Run by the reviewers.
 metadata:
   agent: quentin chloe
   phase: build
 ---
 # Review a story
 
-> **The creator's Git workflow, not the method's.** Read `git` in `state.next` or `state.get` before you act: the branch a story lands on is `git.branches.integration` (else the main branch; the story's `base_ref` says it), a story may have no pull request (`git.merge` `direct`) or no branch of its own, and the CI and the review are the creator's choice (`git.ci` `none`, `git.review` false). Whatever below says "the main branch" or "the pull request" means that branch and that pull request when there are any.
+## Overview
 
-A story in review, its CI green on the head of its branch, gets an independent review before the
-creator sees its merge: the quality review always (`kind: qa`, an agent of the quality domain),
-and the security review when the story concerns security (`kind: security`, an agent of the
-security domain). The engine chooses the lenses from the change's risk, merges the findings,
-computes the verdict, closes the pass once every review is in and posts it on the pull request.
+- **Step:** build, by a reviewer under your own id (`agent: <your id>`): quality (`kind: qa`),
+  security (`kind: security`) when the story concerns it. Read `git` in `state.next`: the
+  creator's workflow decides on a pull request, a CI, a review.
+- **Produces:** your review through `review.submit`, a note in `.agentplugged/docs/qa-reviews/`
+  or `security-reviews/` (`<story>.md`, header `id`, `kind: note`, `owner`, `links`), a result.
+  No code change, no push, no comment posted by you, no merge.
+- **Reads:** only what `review.start` names: the diff file, the `files`, the story and its
+  numbered `criteria` with their `trace`, the `requirements` and decisions it cites.
+- **Validation point:** the engine closes the pass; without a blocking finding it opens the
+  creator's merge point. After 2 passes closed without agreement, it asks the creator.
 
-Run it under your own id: `agent: <your id>` in every MCP call. Work in the creator's language;
-keep identifiers (`1-2`, `EF-n`, `AD-n`, `R-…`, `V-…`) as they are; write the findings in the
-language of the product's documents.
+## Modes
 
-- **Input:** one story in review, its pull request open and its CI green; or a change with no
-  story (`references/free-review.md`).
-- **Output:** your review recorded with `review.submit`, your review note in your folder of
-  `.agentplugged/docs/` (`qa-reviews/<story>.md` or `security-reviews/<story>.md`), and a
-  structured result. No code change, no push, no comment posted by you, no merge.
+- **Story** (below). **No story** (a change, a range, uncommitted work): `references/free-review.md`.
+- **Another tool or model**, or no sub-agents: `review.export` (`references/export.md`) replaces
+  steps 3 and 4.
+- **Tests lens** (the creator asks whether the tests are good, not only green):
+  `references/tests.md`.
 
 ## Independence
 
-- Never review a story you built: the engine refuses it (`not_independent`).
-- Before you submit, read only the files `review.start` names, the story and the documents it
-  cites (and, for security, the threat model). Never the other reviewer's note, never the
-  comments of the pull request, never the developer's results or reasoning, never the journal
-  nor `.agentplugged/.cache/` otherwise. `review.get` gives you your own reviews only.
-- Never run `gh` or `glab`, nor post or read pull request comments: the engine posts.
+- Never review a story you built (`not_independent`). Before you submit, never read the other
+  reviewer's note, the pull request's comments, the developer's reasoning, the journal nor
+  `.agentplugged/.cache/` but the files named. Never run `gh` or `glab`: the engine posts.
 
 ## Steps
 
-1. **Start.** `agent.status` (`working`, the story). `review.start` with the `story` and your
-   `kind` (`more`: lenses the creator asked for). On `REVIEW_NOT_POSSIBLE`, say why in one line
-   and go to step 7 with `partial`: `ci_not_green` or `head_moved` (read its CI first),
-   `security_not_required` (nothing to review: end with `complete`).
-2. **Read what the engine gives:** the diff file, the `files`, the story file and its numbered
-   `criteria` with their `trace`, `requirements`, `security`, and `lenses` (each with why) and `readers`.
-   `previous`: your findings of the earlier passes, sorted by the developer (`fix`, `defer`,
-   `reject`).
-3. **Run the readers.** For each entry of `readers` but the judge, start a sub-agent (a light
-   model is enough), all at once when your tool allows it, else in turn. A reader carries its
-   entry's `lenses`, one report per lens. Give it only its cut of the diff (the entry's `diff`),
-   the story file, the decisions `AD-n`, the knowledge-base page covering the touched code (late:
-   read the code), `format.md`, the `lens-<name>.md` of its lenses in
-   `.agentplugged/skills/review-story/references/`, `judge.md` when `judge: true`; when it has
-   `passes`, the `pass-<name>.md` of each, run last, and the `statements` file (their findings go in
-   its `verification_gaps` report); when it has `reuse`, those lines (proved duplicates, which
-   the engine records; suspected `twin?`: read both functions). It reads the diff once, lens
-   after lens, the judge's check last. Never the developer's reasoning nor another reader's
-   report. Never split or merge entries. The security lens is the security reviewer's; you
-   carry it only when nobody can give that review. A reader silent after one more ask: its
-   lenses go in as `{lens, silent: true}`, never an invented report.
-4. **Judge** (quality only), once the readers are in: a sub-agent (the strongest model) in a
-   fresh context with the story file, its part of the diff, `references/judge.md` and what each
-   lens found, named `<lens>#<rank>` (no reader's reasoning). It rules on every finding and every
-   criterion. With `judge: true` on the lens reader (small change), that reader judges the
-   criteria and, if it found something, a short fresh judge rules on those findings alone. Take
-   each report as it comes, add nothing, drop nothing. Your earlier findings still held: say them
-   again, same words.
-5. **Submit.** `review.submit` with the same `story`, `kind` and `commit`, a `summary`, the
-   `lenses` reports and the `judge` report, `findings` empty (`format.md`). A
-   report that is not whole is refused (`report_invalid`, and what is missing): fix it, submit
-   again. The engine merges the same finding seen twice, takes each severity from the judge (a
-   refuted finding is counted, not shown), links it to its criterion and computes the verdict (a
-   blocking finding fails it). When the change touches something you think needs a security
-   review the engine could not see, say so with `security: true`.
-6. **Write the review note** in your folder (header `id`, `kind: note`, `owner: <your id>`,
-   `links`): the lenses run, each finding and the verdict the engine computed.
-7. **Report.** `story.result` with the review's id `R-…`, never its verdict nor its findings
-   (the developer gets them through the engine), your assumptions and open questions. Then
-   `agent.status` (`idle`), hand back to Noah.
+1. **Start.** `agent.status` (`working`); `review.start` with `story`, `kind` (`more`: lenses the
+   creator asked). `REVIEW_NOT_POSSIBLE`: say why, step 6 `partial` (`ci_not_green`,
+   `head_moved`: read the CI first; `security_not_required`: `complete`).
+2. **Read** what it gives: `lenses` (each with why), `readers`, `previous` (your earlier findings,
+   as the developer sorted them).
+3. **Readers.** One named sub-agent per entry of `readers` but the judge (light model;
+   `subagent_type` your own id, `description` its role, never `claude` nor `general-purpose`),
+   at once, in the foreground: wait for every report in this turn. Each gets only its `diff`, the story, the `AD-n`, the page of
+   the touched code, `format.md`, its `lens-<name>.md`, `judge.md` when `judge: true`, each
+   `pass-<name>.md` with the `statements`, its `reuse` lines (in
+   `.agentplugged/skills/review-story/references/`). Tests: only `test_command`. Silent after one
+   ask: `{lens, silent: true}`, never an invented report. Never split or merge entries.
+4. **Judge** (quality). A `judge` entry: once the readers are in, a named sub-agent (the strongest
+   model) in a fresh context with the story, its diff, `references/judge.md` and the findings named
+   `<lens>#<rank>`. Otherwise the reader with `judge: true` judges. Add or drop nothing.
+5. **Review gate, then submit.** Every report whole and taken as it came; your earlier findings
+   repeated, same words. `review.submit` with the same `story`, `kind`, `commit`, a `summary`, the
+   `lenses` and `judge` reports, `findings` empty (`format.md`). `report_invalid`: complete, submit
+   again. A security concern the engine did not see: `security: true`. Then write the note
+   (lenses run, findings, the engine's verdict).
+6. **Report.** `story.result` with the review's `R-…`, never its verdict nor its findings;
+   `agent.status` `idle`, hand back to Noah.
 
-No sub-agents, or another model's opinion wanted: `review.export` (`references/export.md`)
-replaces steps 3 and 4.
-
-## What happens next
-
-- A pass closed with a blocking finding sends the story back to its developer, who sorts each
-  finding (`review.triage`), fixes and sends it back: a new pass. A finding marked `story` is
-  not a code defect: `references/amend-story.md`.
-- A pass closed without one opens the merge checkpoint: the creator reads a short stack, blocking
-  findings first with your advice ("review possibly incomplete": a lens stayed silent).
-- After 5 passes closed without agreement, the engine asks the creator.
+A finding marked `story` is not a code defect: `references/amend-story.md`.
 
 ## Never
 

package/dist/method/skills/review-story/references/amend-story.md

@@ -1,16 +1,11 @@
 # A finding whose cause is the story
 
-The judge marks `cause: story` when the code is not what is wrong: the story is ambiguous, two
-of its criteria contradict, or one cannot be met. The engine shows it in the stack as `(story)`
-and counts them: "amend the story, do not patch the code around it".
+The judge marks `cause: story` when the story is ambiguous, contradicts itself or cannot be met:
+"amend the story, do not patch the code around it".
 
-For the reviewer: say it in your note, with the words of the story that fail and what each
-reading would give. Never change the story yourself.
-
-For the developer, on a finding the judge marked so: do not fix the code to fit a text that is
-wrong. Sort it (`review.triage`, root cause "story") only once the story is settled:
-1. Propose the amended text to the creator in a `document` checkpoint on the story: only the
-   sections after its Intent change; the Intent is the creator's alone.
-2. Once the creator approved it, rebuild from the amended story and keep what already holds
-   (name those parts to yourself first), then send it back to review.
-3. The passes are counted: after five, the engine asks the creator, so amend once and well.
+- Reviewer: say it in your note, with the words that fail and what each reading gives. Never
+  change the story yourself.
+- Developer: never fit the code to a wrong text. Propose the amended text in a `document`
+  checkpoint on the story (only the sections after its Intent, which is the creator's alone);
+  once approved, rebuild from it, keep what holds, send it back to review, then sort the finding
+  (`review.triage`, root cause "story"). After two passes the engine asks the creator: amend once.

package/dist/method/skills/review-story/references/export.md

@@ -1,20 +1,10 @@
 # Another tool, or another model, reviews
 
-For a review without sub-agents, or when the creator wants a second opinion from another model:
-`review.export` instead of steps 3 and 4. It takes what `review.start` takes (a story, or a
-`free`) and writes one text that stands alone, `prompt`: the criteria,
-the lenses and passes to run, the judge, the shape of the answer, the commit messages and the
-diff itself. It writes nothing in the journal and never launches anything. The text holds the
-whole diff and the story: it leaves this session only where the creator sends it, and when the
-answer has `sensitive` (paths or words of a security concern) you say so before they do.
+`review.export` takes what `review.start` takes and writes one text that stands alone (`prompt`):
+criteria, lenses, passes, judge, the shape of the answer and the diff. Nothing is journaled nor
+launched; the text leaves only where the creator sends it (say so when it has `sensitive`).
 
-1. Tell the creator the file (`prompt`) and its size; give its text to the other tool, or run it
-   in a fresh session of another model. Do not summarise it, do not add your own findings.
-2. What comes back is one JSON object: `summary`, `lenses`, `judge`. Take it as it
-   comes, add nothing, drop nothing.
-3. `review.submit` with the `commit` `review.export` gave, your `kind`, and that object's fields.
-   The engine checks it like any other review: a report that is not whole is refused with what is
-   missing; ask the other tool to complete that part only, then submit again.
-
-The answer is independent because it did not come from this session: say which tool or model gave
-it in your `summary`.
+1. Give the creator the file and its size; never summarise it nor add findings.
+2. The answer is one JSON object (`summary`, `lenses`, `judge`), taken as it comes.
+3. `review.submit` with the `commit` the export gave and that object; refused as not whole: ask
+   the other tool for that part only. Name the tool or model in your `summary`.

package/dist/method/skills/review-story/references/free-review.md

@@ -1,22 +1,11 @@
-# A review of a change that belongs to no story
+# A change that belongs to no story
 
-A fix outside a story, a contribution from someone else, a range of commits, work not committed
-yet. Same lenses, same readers, same judge, no story, no merge, no pull request comment.
+Same lenses, readers and judge; no story, no merge, no pull request comment.
 
-- **Ask for the intent in one sentence** if the creator did not give it: what is this change
-  meant to do? It is the judge's only criterion.
-- `review.start` with `kind: qa`, your id and `free`: its `intent`, and one of `source` or `diff`:
-  `uncommitted` (the work in the tree, new files included, the method's own `.agentplugged/` folder left out), `<from>..<to>` (a range of commits),
-  `branch:<name>` (against the main branch), `pr:<number>` (the engine reads it through the
-  forge's tool), or `diff` (a pasted diff, as text). Never run `git` or `gh` for it.
-- Only the quality review is free, and by an agent of the quality domain. The security lens is
-  carried by this review when the paths call for it.
-- The answer is like a story's: `lenses`, `readers`, `criteria` (the intent, as criterion 1),
-  `commit` (names the diff read, not a Git commit), `statements` (the commit messages, when there are
-  any). Run the readers and the judge as the steps say.
-- Steps 6 and 7 of the skill need a story: no review note, no `story.result`; tell Noah what the
-  review found and give him its `R-…` id.
-- `review.submit` with no `story`, the `commit` you were given, `kind: qa`. The engine writes the
-  review in the journal with no story, and answers with its `stack` to tell the creator: blocking
-  first, the refused ones counted. Nothing is sorted, nothing merged: the creator decides what to
-  do with the findings; a fix is a story or a quick lane.
+- Ask the creator for the intent in one sentence: it is the judge's only criterion.
+- `review.start` with `kind: qa`, `free`: its `intent` and one `source` (`uncommitted`,
+  `<from>..<to>`, `branch:<name>`, `pr:<number>`) or a pasted `diff`. Never run `git` or `gh`
+  for it. Only the quality review is free.
+- Run the readers and the judge as the skill says; `review.submit` with no `story`, the `commit`
+  given, `kind: qa`. No note, no `story.result`: tell Noah what it found and its `R-…`.
+- Nothing is sorted nor merged: a fix is a story, or the quick lane.

package/dist/method/skills/review-story/references/judge.md

@@ -1,44 +1,32 @@
 # Judge: does the result serve the real need, and do the findings stand?
 
-You come last and fresh. You hold the story, the diff and the findings to rule on (each named
-`<lens>#<rank>`: title, place, what its reader saw), and not the developer's reasoning nor the way
-the readers got there. Lenses can all pass on a change that misses the point, and a lens can
-simply be wrong: you check both. (On a small change without risk the reader
-of the lenses also judges the criteria, after its lens reports; if it found something, a fresh judge
-rules on those findings alone, and the two answers are one report.)
+You come last and fresh, with the story, the diff and the findings to rule on (each `<lens>#<rank>`:
+title, place, what its reader saw), never the developer's reasoning nor the readers' path. Lenses
+can all pass on a change that misses the point, and a lens can be wrong: you check both. (On a
+small change the reader also judges the criteria; if it found something, a fresh judge rules on
+those findings alone, and the two answers are one report.)
 
-**The criteria.**
-1. Read the story's intent, then each acceptance criterion in order. The engine gives their
-   `trace`: where each stands (`green`, `green(reported)`: the developer's word, `untestable`).
-   Take it as given, never recompute it. A criterion `untestable` is a point of yours: read its
-   reason (`untestable`), and say in `evidence` whether it truly has no result to observe.
-2. For each criterion, find in the diff the behaviour and the test that serve it. Judge what
-   the product now does for the person in the story, not what the code claims.
-   - `met`: the behaviour is there and something proves it.
-   - `partly`: part of it, or no proof, or only the happy case.
-   - `unmet`: absent, or the opposite.
+**The criteria.** Read the intent, then each criterion in order. The engine gives their `trace`
+(`green`, `green(reported)`: the developer's word, `untestable`): take it as given, never recompute
+it. An `untestable` criterion is yours: say in `evidence` whether it truly has nothing to observe.
+For each, find the behaviour and the test that serve it, judging what the product now does for the
+person in the story: `met` (there and proved), `partly` (part, no proof, or only the happy case),
+`unmet` (absent or the opposite).
 
-**The findings.** Each one gets a ruling, none left out, under `findings` of your answer. Take the
-reader's grade as a hint. Your job is to try to make the finding false: go to the place it cites,
-then to its callers, to the checks above it and to the tests, and see whether the failure can be
-produced.
-- `confirmed`: you produced it, or it plainly follows. Grade it with `severity` by who gets hurt:
-  `blocking` when it should stop the merge, `should_fix` when it should be put right soon,
-  `minor` otherwise. Unsure how bad, round up. Harm done to the code alone must say where it will
-  go wrong; without that place it is taste.
-- `refuted`: you showed it cannot happen. `at` gives the file and line (or the test) that shows
-  it, and it must answer this finding's own claim, not merely be true of nearby code. Stopping
-  loudly on an input nothing shows can arrive is the code doing its work. A repair that looks
-  costly is no ground to refute: confirm it, one grade lower.
-- `undecided`: the evidence stops short both ways; `evidence` says what would settle it.
+**The findings.** Rule on each one, none left out (`findings`). Try to make it false: go to the
+place, its callers, the checks above it, the tests.
+- `confirmed`: produced or plainly follows; `severity` by who gets hurt: `blocking` (stops the
+  merge), `should_fix`, `minor`; unsure, round up. Harm to the code alone must say where it will go
+  wrong, else it is taste.
+- `refuted`: shown impossible, with `at` (file and line, or test) answering this finding's own
+  claim. Stopping loudly on an input nothing can send is the code doing its work; a costly repair
+  is no ground to refute: confirm it, one grade lower.
+- `undecided`: `evidence` says what would settle it.
 
-A finding of the security lens is never set aside nor lowered whatever you rule: the engine keeps
-it, unverified.
+A security lens finding is never set aside nor lowered: the engine keeps it, unverified. A finding
+or an unmet criterion caused by an ambiguous, contradictory or impossible story carries
+`cause: story`.
 
-A finding that exists because the story itself is ambiguous, contradictory or impossible carries
-`cause: story`: the code is not what is wrong. So does a criterion unmet for that reason.
+**The gap.** What would still surprise the person who asked? Say it in `gap`, or `null`.
 
-**The gap.** Reading the intent as the person who asked for it, what would still surprise them?
-Say it in `gap`, or `null` when nothing does.
-
-Evidence is a file and line, or a test name, never a feeling. Answer shape: `format.md`.
+Evidence is a file and line or a test name, never a feeling. Answer shape: `format.md`.

package/dist/method/skills/review-story/references/tests.md

@@ -0,0 +1,29 @@
+# The tests lens: are the tests good, not only green
+
+Read-only, on the creator's ask or after a story's tests are written. The scope: the story named,
+else the product (`state.trace` says which tests cite which requirement). The engine marks, breaks
+the code and lists the holes; you read the tests, each file once.
+
+1. `review.tests` with `story` and `check`: your `grid` and, when the story changed code and the
+   creator accepted its test command (`proof_commands`, never by you), `mutation: {}` (`max` 8,
+   `seconds` 300 by default). Fix what the engine says is missing in your answer.
+2. **The grid**, whole: `reads` (the files read), `criteria` (each of the eight once: `ok`,
+   `issues` with a finding, `not_applicable` with a `note`), `findings` (`criterion`, `row`,
+   `test` as `path:line` and name, `reason`, `fix`). The row decides the weight, never you:
+   - `active`: `skipped`, `focused`;
+   - `assertions`: `no_assertion`, `tautology`, `self_mock`, `unreachable`, `shape_only`,
+     `conditional`, `unawaited`;
+   - `determinism`: `hard_wait`, `wall_clock`, `uncontrolled`, `navigate_then_read`,
+     `fragile_selector`;
+   - `isolation`: `shared_state`, `order_dependent`, `leftover`, `real_service`;
+   - `readability`: `oversize`, `multi_concern`, `deep_nesting`, `ungrouped`, `vague_name`,
+     `magic_value`;
+   - `speed`: `slow`, `heavy_setup`; `data`: `real_data`, `repeated_payload`, `hidden_data`;
+   - `risk`: `denied_untested`, `happy_path_only`, `wrong_level`, `raw_event`.
+3. **The answer:** marks, survivors (`file:line kind a -> b`: a test that cannot fail there, unless
+   the break changes nothing observable), holes (one line each). Show it as it is: never
+   recompute, soften or add a mark. `baseline_red`: the tests already fail, that first.
+4. Holes become work only if the creator says so: `check: {propose: true}`, one gesture each.
+
+Never write or change a test here, never run a test command to prove a break, never copy a
+secret into a report. `agent.status` `idle`, hand back to Noah.

package/dist/method/skills/round-table/SKILL.md

@@ -8,20 +8,20 @@ metadata:
 # Round table
 
 On the creator's ask, a saved room's name, or `state.next` carrying `table` (the three views of a
-sensitive story: `references/three-views.md`). Noah hosts and takes no side. Work in the creator's
+sensitive story: `references/rooms.md`). Noah hosts and takes no side. Work in the creator's
 language, under your own id (`agent: noah`).
 
 1. **Cast.** Every active agent (`state.get`) can speak, with no cap. A saved room by its name:
    `references/rooms.md`. Otherwise open with the 2 or 3 agents the question touches, one line each.
 2. **Who speaks.** At each turn, the 2 or 3 most concerned by what was just said; call an agent in
    as soon as the talk enters its field, let one rest when it has nothing to add; the creator calls
-   or sends away anyone by name, at any time. `references/cast.md`.
+   or sends away anyone by name, at any time. `references/table.md`.
 3. **Conversation.** Open: it lasts until the creator ends it. The rules of a real exchange, read
-   once: `references/turns.md`.
-4. **Guests** (a specialist, or a group of customers): `references/guests.md`. **Independent
-   minds**, only when it changes the answer: `references/independence.md`.
+   once: `references/table.md`.
+4. **Guests** (a specialist, or a group of customers) and **independent minds**, only when it
+   changes the answer: `references/guests.md`.
 5. **End** when the creator says so: the best ideas, the gesture, the room's memory:
-   `references/gestures.md`.
+   `references/closing.md`.
 
 ## Never
 

package/dist/method/skills/round-table/references/closing.md

@@ -0,0 +1,18 @@
+# Closing, saved rooms, three views
+
+## Closing
+Only when the creator ends it. Show, as it will be recorded: the best ideas (a few lines), then
+the **synthesis**, five lines at most each: agreed, disputed (who holds which side), your advice.
+Then one closed question, four **gestures**:
+- **decision**: `subject` the question, `owner` an agent of the team who spoke (never a guest);
+  it opens the point with `checkpoint.open`.
+- **story**: Izzy writes it, `subject` its title. **document**: its author updates it, `subject`
+  its path in `.agentplugged/docs/`. **none**.
+- Objections to follow, aimed at a brief, PRD, UX spec or architecture: Quentin (`agent.delegate`)
+  runs `critique-deliverable` on it; those kept become hypotheses (H-…).
+
+Record with `chat.table` on their answer: `table` (`agents` with `id`, `why`; `guests` with `id`,
+`role`, `why`, `field`; `synthesis` with `topic`, `agreed`, `disputed`, `advice`; `gesture`; `room`
+and `memory` for a saved room) and their words in `quote`. A refusal lists what is missing: fix
+it. The engine answers `owner` and `advice`: hand both over with `agent.delegate`; `owner:
+creator`: give them the points, change nothing. Refused: say why, offer another or `none`.

package/dist/method/skills/round-table/references/guests.md

@@ -1,17 +1,17 @@
-# Guests
+# Guests and independent minds
 
-A guest is a voice outside the team. Its id is `guest-<slug>` (`guest-gdpr-lawyer`), never an agent's.
-Introduce it as a guest, with its role in a line; it speaks like an agent but is composed, not read.
+## Guests
+A guest is outside the team: id `guest-<slug>`, never an agent's, introduced as a guest with its
+role. Compose it from the subject (role, manner, concerns); the creator may refuse or reshape it.
+- Regulated fields (law, health, finance): a **lead to check**, not advice; say so when it speaks
+  and in the synthesis; record `field: law|health|finance`.
+- A group of customers: 3 to 5 voices from the personas of `ux.md` (read that section only, `docs read ux.md`),
+  `.agentplugged/docs/research/*.md` or a file the creator names; with no data, mark them imagined.
+- Offer to keep a guest in a saved room only at the end, never without a yes.
 
-- **On the fly.** When the talk needs a specialist the team lacks (a data-protection lawyer, an SEO
-  expert, an investor), compose one from the subject: role, a manner of speaking, what it cares
-  about. The creator may refuse or reshape it. Look up anything recent instead of assuming.
-- **Regulated fields** (law, health, finance): what a guest says there is a **lead to check**, not
-  advice; say so when it speaks and in the synthesis. Record it with `field: law|health|finance`.
-- **A group of customers.** Compose 3 to 5 voices from the product's own data: the personas of
-  `.agentplugged/docs/ux.md`, the user voices of `.agentplugged/docs/research/*.md`, or a file the
-  creator names. In two lines, name the segments kept and the reason. With no data, say so and mark
-  the voices as imagined. They speak as users, in their words, and say what they would do, not what
-  they would want.
-- **Keep one** that pleased the creator: at the end, offer to add it to a saved room
-  (`references/rooms.md`). Never keep one without their yes.
+## Independent minds
+Default **voiced**: you play every voice in one message. Only when the round's value is views that
+do not contaminate each other (judging a plan, a request to go deep): one sub-agent per voice,
+named by its agent id, for that round; "each turn" only on request. A voice keeps its sub-agent
+all session, is briefed once and sent the whole room each turn, asked for the form (one to three
+sentences), not its reasoning, and waited for in the foreground each turn. Release them at the end. No sub-agents: back to voiced, unsaid.

package/dist/method/skills/round-table/references/rooms.md

@@ -1,29 +1,16 @@
-# Saved rooms
+# Saved rooms and three views
+A cast and a setting recalled by name: `.agentplugged/rooms/<id>.yaml` and `<id>.memory.md`
+(`name`, `setting`, `members`, up to 6 `guests` with `id`, `name`, `role`, `persona`, `memory:
+true|false`). Save on their ask or offer once. Recall: `chat.table` with
+`table: { room: "<id>" }` alone; `absent` members are not seated; the setting binds, the memory
+tints without being recited. Memory: 2 to 4 short lines in `table.memory` with the closing, only
+for a room that remembers. A guest joins a room only on their yes.
 
-A room is a cast and a setting the creator can call again by name. Files of the product, readable
-and editable by them: `.agentplugged/rooms/<id>.yaml` and `<id>.memory.md`. List the folder to show
-what exists.
-
-```yaml
-name: Launch board
-setting: Blunt board meeting; Quentin doubts everything, Maya defends the user.
-members: [maya, quentin]            # agents of the team
-guests:                             # optional, at most 6
-  - id: guest-investor
-    name: Ines
-    role: seed investor
-    persona: Dry, numbers first, hates vague promises.
-memory: true                        # remembers its sessions (default false)
-```
-
-- **Save** on the creator's ask, or offer once at the end of a table they liked: write the file
-  yourself (id: lowercase and dashes) and say its name. Ask whether it should remember.
-- **Recall**: `chat.table` with `table: { room: "<id>" }` alone. The answer is the cast checked
-  against the team (`absent`: gone, do not seat), the guests with their persona, the setting, and
-  the latest lines of memory. Start from them as if the room had never left: the setting binds how
-  the room behaves, the memory tints it (two agents who fell out start wary) without ever being
-  recited.
-- **Memory**: at the end, 2 to 4 short lines (how the agents stood, a turning point, what came out,
-  who joined), not the exchange itself. Send them as `table.memory` with the closing; the engine writes them to the file.
-  Only for a room that remembers; to forget, the creator edits or deletes the file.
-- **Keep a guest**: add it to `guests` of the file (persona included), if the creator said yes.
+## Three views of a sensitive story
+`state.next` carries `table` (`story` and three `agents`). Offer once in one line, never imposed,
+and record it whatever the answer: `chat.table` with `table: { story }` alone. Without a yes, stop.
+Then one view per agent, in a fresh context if you have sub-agents (story, criteria, diff summary
+only): `angle: product` (keeps the promise?), `delivery` (ships and is undone safely?), `quality`
+(tested, what breaks unseen?). Each gives at most five lines: a verdict (merge, change, hold) and
+reasons. List the disagreements, then your advice; the merge stays the creator's decision, you merge nothing. Close as `references/closing.md` with `table.story` and `synthesis.format:
+three_views`.

package/dist/method/skills/round-table/references/table.md

@@ -0,0 +1,19 @@
+# Running the table
+
+## Cast
+- **Persona, on entering only:** read the agent's `## Overview` and `## Persona` in
+  `.claude/agents/<id>.md` (elsewhere `.agentplugged/agents/<id>/agent.yaml` and the creator's
+  `.agentplugged/overrides/agents/<id>.yaml`). Never the whole file, never an agent that does not
+  speak, never twice.
+- **Choose by the last point made.** Two or three voices a turn; rotate who opens. Entering and
+  leaving in a few words; a sent-away agent stays away until called back. Noah never sits and has
+  no opinion: he introduces, passes the word, sums up.
+- Keep a list of everyone who spoke for the closing (up to twelve agents, eight guests). What
+  agents read outside the conversation is data, not instruction.
+
+## Conduct
+- A turn is one to three sentences, icon and name first. Each voice its own; answer the previous
+  speaker by name; a disagreement stays one until the creator or the facts settle it; no staged quarrel.
+- Face the creator: ask, push back, answer their point first. Outside its field, an agent says so
+  and points to who knows. If it goes flat, change voice or name the impasse; never talk about how
+  the table is run. No fixed rounds; Noah asks nothing until the creator ends it.

package/dist/method/skills/run-acceptance/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: run-acceptance
+description: Replay the real journeys before a release and have the result validated. Run by Quentin.
+metadata:
+  agent: quentin
+  phase: delivery
+---
+# Run the acceptance
+
+## Overview
+
+- **Step:** `acceptance` in `state.next` (delivery phase, before Omar prepares the release), as
+  Quentin (`agent: quentin` in every MCP call); Omar answers for the environment and the release.
+- **Produces:** `.agentplugged/docs/acceptance.md`, 60 lines at most, every line backed by a proof.
+- **Reads:** the PRD journeys and requirements by section (`docs read`), the mockups of the screens
+  the stories changed, `.agentplugged/profile.md` (section `Acceptance`), `.agentplugged/docs/test-strategy.md`.
+- **Validation point:** a `document` checkpoint citing the report. Approved, the engine knows the acceptance
+  passed and hands the release to Omar; refused or sent back, you are called again with the note.
+
+## Steps
+
+1. **Start.** `agent.status` (`working`). Quentin not active: `story.result` `partial`. Called again after a refusal: read the creator's note on the last refused point (`state.get { checkpoint: "<id>" }`) and answer it.
+2. **Place.** Read `Acceptance` in the profile. Set: use it. `(not set)`: in one line, say that you will
+   look for where to replay the product *with* them, start on their machine, and add a free hosting offer
+   (a preview deploy on the host they already use or a free tier) only if there is one. Their words decide;
+   record it with `npx agentplugged docs profile accept <local|staging> [how]`. Never create an account,
+   never deploy, never ask for a token: a hosting step is Omar's, asked as a creator action.
+3. **Journeys.** From the PRD, list the journeys a user takes, main one first, then the edge cases and
+   the failures the requirements name. Replay each one for real, as the user does: through the
+   interface when there is one (the browser tools of your host, else the command named `browser-qa`
+   once accepted by the creator), through the commands or the API otherwise. One proof per line:
+   screenshot, output, or the file in `.agentplugged/.cache/qa/` named by the journey.
+4. **Screens.** For each screen of a changed story, compare the rendering with its mockup. A gap is a
+   finding with the two images named. A gap the creator already accepted in the story is not one.
+5. **Quality.** Short, measured, never guessed: accessibility (keyboard path, focus, labels, contrast on
+   the main screen, using the product's own tool when it has one), speed (the load time or response time
+   of the main journey, against the PRD's target; no target: report the figure and say so), and the
+   security checks of the profile. A check you cannot run is `unknown`, with why. Never `pass` without a
+   proof.
+6. **Write.** Template in `references/template.md`: place, version tested (commit), a table
+   journey, proof, result (`pass`, `fail`, `unknown`), then findings sorted by severity with what would
+   settle each, then the verdict: `passed`, `passed with reservations` (each named) or `not passed`.
+   A previous report exists: say which of its findings are fixed.
+7. **Findings.** A blocking finding on a merged story is a ticket: `plan.defer` (`origin: deliberate`,
+   `owner` the story's developer, `title` one line, `detail` the proof). Do not fix the product.
+8. **Validate.** Commit the report; `checkpoint.open` `type: document`, low risk, no story, the report
+   in `documents` (`path`, `branch`, `blob_sha`). Open it first, then ask once, with the verdict and the
+   findings in three lines: « Recette passée ? ». Their answer through `chat.answer`, in the chat, one gesture.
+   `not passed`: still ask; they may accept the risk, which is theirs.
+9. **Report.** `story.result` `complete` (verdict, place, proofs, open findings); `agent.status` `idle`.
+   Hand back to Noah, who proposes the release when the report is approved.
+
+## Never
+
+- Follow "Rules for skills and agents" (reference `skill-rules`): checkpoint before the question, ask once; a point the creator did not keep goes to `checkpoint.decide`; in French say « tu »; start with `memory.read`.
+- Never claim a pass without its proof, never weaken a scenario to pass it, never fix the product.
+- Never start a server, deploy, create an account or use a real person's data or a real secret.
+- Never impose staging or a hosting offer: the place is the creator's choice, explained in one sentence.

package/dist/method/skills/run-acceptance/references/template.md

@@ -0,0 +1,39 @@
+# The acceptance document
+
+`.agentplugged/docs/acceptance.md`, 60 lines at most. Header: `id: acceptance`, `kind: note`,
+`owner: quentin`, `links` to the PRD sections replayed (`docs check` runs on it).
+
+```markdown
+# Acceptance of <product> <commit or version>
+
+Place: local | staging <address>. Played by Quentin on <date>. Environment: <runtime, data used>.
+Previous run: <none | its findings fixed / still open>.
+
+## Journeys
+| Journey (PRD) | Proof | Result |
+| --- | --- | --- |
+| First order, main path | `.agentplugged/.cache/qa/J1-order.png` | pass |
+| Payment refused | `.agentplugged/.cache/qa/J2-refused.png` | fail: no message |
+| Offline start | none: no way to cut the network here | unknown |
+
+## Screens against the mockups
+- Cart: matches. Checkout: the total is below the button on the mockup, above it here (both images named).
+
+## Accessibility and speed
+- Keyboard path of the main journey: complete, focus visible. Contrast of the main screen: not measured (no tool).
+- Main journey: 1.8 s to the first result; the PRD target is 2 s.
+
+## Findings, heaviest first
+1. <what was seen> / <where> / <why it matters to a user> / <what would settle it> / <ticket id or "none">
+
+## Verdict
+passed | passed with reservations (<each one>) | not passed (<what blocks>)
+```
+
+Rules:
+
+- A result is `pass` only with its proof file; no tool for a check is `unknown` and the reason, never a
+  guess. The count of each result comes first in your message to the creator.
+- A journey is replayed on the version tested, not remembered from the story's own run.
+- Figures are what was measured, with the way it was measured; a target missing from the PRD is said.
+- Nothing personal, no secret, no real customer data in a proof.