agentplugged 1.2.0 → 1.4.0

package/dist/method/skills/strategy/references/gestures.md

@@ -1,24 +1,15 @@
 # From conclusions to gestures
 
-At the end of the file, list in a few lines what the work concluded: the cause found, the option chosen,
-the bets under the strategy. For each, ask the creator once which gesture they want. They may answer
-some now and the rest later. Never choose for them.
+List what the work concluded. Ask once which gesture for each; some may wait. Never choose for them.
 
-- **Hypothesis followed.** A bet that must be proved (a cause not yet verified, an option that may not
-  work, a market claim, a price): `review.critique` with `kind: idea`, `lenses: ["pre_mortem"]`, a
-  `summary` (what the file is), and at most twelve findings, one per bet (`severity`, `claim` in one line of 200 characters at most,
-  `passage` a label of 120 at most that cites the `EF-n` or `AD-n` the bet touches, so that it comes back when
-  a story citing it is delivered, `argument` of ten characters or more, and unless the bet is minor
-  `proposal` and `proof`, what would prove or refute it). An earlier idea report not yet sorted
-  (`critique_unsorted`) is sorted first. Then the gestures
-  and the calls of the skill `critique-deliverable`
-  (`.agentplugged/skills/critique-deliverable/references/gestures.md`): keep as a hypothesis, drop with
-  their reason, or correct the file. A hypothesis kept comes back when its proof arrives; close it with
-  their words only.
-- **Story proposed.** One line each under `## Plan` or `## Roadmap` (`Story proposed:` the change, the
-  reason, the source). Hand the kept ones to Noah in your closing line: a new requirement goes to Maya, a
-  story to cut to Izzy. Write no story and no requirement yourself.
-- **Decision point.** A choice between two to four options that only they can make (the direction, the
-  price model, the fix): `checkpoint.open` with `type: decision`, the options, your recommended one and
-  the file in `documents`; ask once. Record the answer in the file once it is given.
-- **Nothing.** The file is enough. Some conclusions are only for the creator to think about.
+- **Hypothesis followed.** A bet to prove: `review.critique` with `kind: idea`, `lenses:
+  ["pre_mortem"]`, a `summary`, at most twelve findings, one per bet (`severity`, `claim` one line of
+  200 characters at most, `passage` a label of 120 at most citing the `EF-n` or `AD-n` it touches,
+  `argument` of ten characters or more, unless minor `proposal` and `proof`). An unsorted idea report
+  (`critique_unsorted`) is sorted first, then the gestures and calls of
+  `.agentplugged/skills/critique-deliverable/references/gestures.md`.
+- **Story proposed.** `Story proposed:` change, reason, source, under `## Plan` or `## Roadmap`; hand
+  the kept ones to Noah (requirement: Maya; story: Izzy). Write no story and no requirement yourself.
+- **Decision point.** Two to four options only they can make: `checkpoint.open`, `type: decision`,
+  your recommendation, the file in `documents`; ask once.
+- **Nothing.**

package/dist/method/skills/strategy/references/innovate.md

@@ -1,40 +1,22 @@
-# Innovation strategy, the course
+# Innovation strategy
 
-Tell the truth about the market before looking for a breakthrough; a flattering picture sinks a strategy.
-Push for evidence over hope, a lasting advantage over a clever feature, a bold idea over a safe one that
-changes nothing, and keep the plan one a solo creator can carry. The creator is not asked to know the
-frameworks: you choose them (`innovate-frameworks.md`, two to four per step), say in a line what each
-reveals, and ask the questions. The sections of the file are the steps; a step not run keeps its
-section with one line saying why.
+Evidence over hope; a plan a solo creator can carry. Choose
+two to four light frameworks per step, say in a line what each reveals. The sections of the template
+are the steps; a step not run keeps its section with one line saying why. By need: no model yet,
+steps 1 to 3 then 7; a price decision, 3 and 7. Then `gestures.md`.
 
-1. **Context.** The business or product, what drives the exploration (pressure, an opening, a plateau),
-   the current model in brief, the limits (money, time, rules, skills), and what a breakthrough would look
-   like. Start from the brief, the positioning and the story if they exist.
-2. **Market.** Segments and how they move; the real competitors, the unexpected ones and the substitutes;
-   what is changing; who is underserved and who overserved. Reuse the research pages (`docs research`);
-   search only what is missing or old, and every size or share carries its source or `[to verify]`.
-3. **Model.** Who is really served and what job they hire the product for; how value is made, delivered
-   and captured today; the honest advantage; where the model is vulnerable; the assumptions that may be
-   false. Revenue and costs are only named here; their figures go to the economics.
-4. **Openings.** Where an entrant could win: non-users to serve, jobs left undone, a good-enough version
-   for a new segment, a technology that just made something cheap, a space where competition is
-   irrelevant. Name the disruption vectors and the white space.
-5. **Options.** Five to ten concrete moves, across the model (how value is made and captured), the value
-   chain (what to do, what to buy), partnerships and technology. Mix the near and the far.
-6. **Direction.** Merge them into three different strategic options. For each: the direction, what it
-   changes in the model, the position against competitors, what it needs, the main risks and
-   dependencies, what to expect. Judge them on fit with the creator's strengths, timing, defensibility,
-   feasibility and risk against reward. Then recommend one or a combination: why, what gives
-   confidence, what worries, the hypotheses to prove first, what would make you change course. The creator
-   decides.
-7. **Economics.** The cost of the product, the price, the revenue, the break-even point: `costs.md`.
-8. **Roadmap.** Three phases, no dates: first the moves that prove the riskiest hypothesis and give
-   momentum; then the foundations (capabilities, the first market, steady growth); then scale and
-   efficiency. For each: the initiatives, what they need, the measures of success, and the decision gate
-   that opens the next.
-9. **Risks.** Early signals (adoption, engagement, efficiency) and results (revenue, share, margin); the
-   go and no-go gates; what could kill the strategy, the assumptions that may be wrong, how competitors
-   may answer, and the backup plan.
+1. **Context**. 2. **Market**: reuse `docs research`; every size or share carries its source or
+   `[to verify]`. 3. **Model**: revenue and costs only named here. 4. **Openings**.
+5. **Options**: five to ten concrete moves, near and far.
+6. **Direction**: three different options, judged on fit, timing, defensibility, feasibility, risk
+   against reward; recommend one, with the hypotheses to prove first. The creator decides.
+7. **Economics**: `costs.md`. 8. **Roadmap**: three phases, no dates, a decision gate between them.
+9. **Risks**: early signals, go and no-go gates, plan B.
 
-Choose by need: no model yet, steps 1 to 3 then 7; a plateau, steps 3 to 6; a decision on price, steps 3
-and 7. Then the gestures (`gestures.md`).
+Frameworks:
+- Market: market size in three rings; five forces; outside forces; timing; positioning map.
+- Model: business model canvas; value fit; model patterns; revenue ideas; cost redesign.
+- Openings: disruption from below; jobs to be done; blue ocean; crossing the gap; platform.
+- Options: three horizons; build, measure, learn; ambition grid; strategic intent; scenarios; value chain;
+  unbundling; ecosystem design; make or buy; partnerships.
+- Technology: adoption curve; S-curve; technology roadmap; open innovation.

package/dist/method/skills/strategy/references/solve.md

@@ -1,35 +1,22 @@
-# Solving a problem, the course
+# Solving a problem
 
-Diagnose before you solve; a good question is worth more than a quick answer. Symptoms lie, structure does not.
-Balance rigour and momentum: do not stay in analysis when the cause is clear. Start from the documents
-(PRD, architecture, research, the hypotheses already followed). The sections of the file are the steps;
-a step not run keeps its section with one line saying why.
+Diagnose before you solve. The sections of the
+template are the steps; a step not run keeps its section with one line saying why. By need: a bug
+that returns, steps 1 to 4; options known, 5 to 8. Then `gestures.md`.
 
-1. **Problem.** Ask: what exactly is wrong, how it was first noticed, who lives it, when and where, what it
-   costs, what success looks like. Write one statement of the gap between today and the wanted state, and
-   say why it is worth solving. Name the kind (technical, product, adoption, organisation, decision).
-2. **Boundaries.** Where, when, who and what it is and is not. Contrast the cases where it happens with
-   the near cases where it does not; the pattern between them is the first clue.
-3. **Causes.** Symptom, cause, cause of the cause, until the answer is something that can be acted on.
-   Offer two or three methods of the diagnosis group (`solve-methods.md`), say when each fits; run them.
-   Separate the root cause from the contributing factors and name the loops that keep the problem alive.
-   Mark each cause `[verified]` (seen in the code, a log, a number) or `[to verify]` (guessed).
-4. **Forces.** What drives toward a solution and what holds it back; which are strongest, which the
-   creator can move. The main constraint, and which limits are real and which only assumed. End with the
-   two or three insights that change what to try.
-5. **Options.** Ask their energy first, then change gear: from analysis to making. Offer two to four
-   methods of the creative and synthesis groups; at least ten options, small and large, and a few wild
-   ones that break an assumption. The creator's ideas first, yours after.
-6. **Choice.** Criteria first, chosen with the creator (effect on the root cause, feasibility, cost,
-   risk, reversibility). One or two evaluation methods. Recommend one option with the reason, the
-   confidence, what still worries, and the assumptions it rests on. The creator decides.
-7. **Plan.** Strategy (a trial first, in steps, or all at once) and why; the actions in order with their
-   dependencies, who does each (the creator, an agent, a tool), what each needs. No dates: order and
-   checkpoints. Learn in loops: plan, do, check, adjust.
-8. **Checks.** How we will know it worked: the measures and their targets, how and how often they are
-   read; the proof wanted, the trial to run first; what could go wrong, plan B, and the sign that says to
-   change course.
-9. **Lessons** (optional, `## Lessons`). What held up, what to drop next time, what surprised, what to remember.
+1. **Problem**: one statement of the gap, who lives it, what it costs, what success is.
+2. **Boundaries**: where, when, who, what it is and is not.
+3. **Causes**: symptom to root, root apart from contributing factors; mark each `[verified]` (seen in
+   code, a log, a number) or `[to verify]` (guessed).
+4. **Forces**: what drives, what holds back, real limits against assumed.
+5. **Options**: at least ten, a few wild; theirs first.
+6. **Choice**: criteria first, with them; recommend one with reason, confidence, worries. They decide.
+7. **Plan**: actions in order, who does each. No dates.
+8. **Checks**: measures, the trial first, plan B, the sign to change course. 9. **Lessons**: optional.
 
-Choose by need: a bug that returns, steps 1 to 4; options known, steps 5 to 8; a plan under way that
-stalls, steps 4 and 8. Then the gestures (`gestures.md`).
+Methods, two or three per step, chosen for the problem (you know them):
+- Causes: statement sharpening; is / is not; five whys; cause map; systems view.
+- Forces: force field; vital few (80/20); gap analysis; bottleneck search; failure modes.
+- Options: contradiction matrix (TRIZ); lateral thinking; morphological grid; nature analogy;
+  analogy chain (synectics); assumption busting; random word; reverse brainstorm; six hats; seven lenses.
+- Choice: weighted matrix; cost and benefit; risk grid; trial protocol; feasibility.

package/dist/method/skills/test-idea/SKILL.md

@@ -12,14 +12,14 @@ more, they pick. Run under your own id (`agent: iris`), in their language. Write
 `.agentplugged/docs/prfaq.md` and `.agentplugged/docs/ideas/forge-<slug>.md`.
 
 1. `agent.status` (`working`). Read the brief and the documents that exist; without any, ask for the
-   idea in a few sentences and keep their words. Name the concept type: `references/concept.md`.
-2. **Forge** (clarify, test or improve it): `references/forge.md`. It ends hardened, killed or clearer.
+   idea in a few sentences and keep their words. Name the concept type (`references/forge.md`).
+2. **Forge** (clarify, test or improve it): `references/forge.md`.
 3. **Test**: `references/personas.md`. The personas attack in a fresh context (one sub-agent plays
-   them in turn when you have one: the idea and that file, never your reasoning). Say the synthesis in a few lines.
-4. **Press release**: `references/prfaq.md`, `faq.md`, `verdict.md`. Write it with them from
+   them in turn when you have one: the idea and that file, never your reasoning).
+4. **Press release**: `references/prfaq.md` (with the verdict) and `references/faq.md`, from
    `assets/prfaq-template.md`; open its `document` checkpoint and ask once.
 5. **Bets**: report them (`kind: idea` after the forge or the test, `prfaq` after the release), then the
-   creator's gesture on each: `references/bets.md`.
+   creator's gesture on each: `references/personas.md`, "The bets".
 6. `agent.status` (`idle`), hand back to Noah.
 
 ## Never

package/dist/method/skills/test-idea/assets/prfaq-template.md

@@ -9,7 +9,7 @@ the creator's language, and remove these comments, the "Generated by agentplugge
 <…> placeholder. Keep the header keys; `links`: the ids of the documents it builds on (the brief, a
 forge). Never add a status, a cost or a progress. Add the sections one by one; to close, add
 `concept: commercial | internal | open-source | community` to the header and `## Verdict` last
-(`references/verdict.md`). -->
+(`references/prfaq.md`). -->
 
 # Press release: <product name>
 

package/dist/method/skills/test-idea/references/faq.md

@@ -1,34 +1,17 @@
 # The two lists of questions
 
-Play the reader who has been let down before, not a fan. Ask what stands between interest and a
-yes. Show all the questions together, then settle the answers one at a time.
+Play the reader who has been let down before. Show all the questions, then settle the answers one at a time. Each list holds **6 to 10 questions**, each opening with its angle:
+`- [safety] Where does my data live? — answer`. The engine checks every angle is asked. A question
+the creator cannot answer also gets `[open]`. In French use `[changer]`, `[sûreté]`, `[effort]`,
+`[rare]`, `[redouté]`; `[construire]`, `[durer]`, `[moyens]`, `[danger]`, `[pourquoi-nous]`, `[évité]`.
 
-Each list holds **6 to 10 questions**, each opening with its angle in brackets:
-`- [safety] Where does my data live? — answer`. The engine checks that every angle is asked
-(`docs check`). A question that cannot be answered from what they said gets a second tag, `[open]`.
-In French use the French word (`[changer]`, `[sûreté]`, `[effort]`, `[rare]`, `[redouté]`;
-`[construire]`, `[durer]`, `[moyens]`, `[danger]`, `[pourquoi-nous]`, `[évité]`).
+**Customer FAQ** (`## Customer FAQ`): `[switch]` why this instead of the current way; `[safety]` data,
+who stands behind it; `[effort]` time to start, price or upkeep; `[rare]` an unusual case;
+`[dreaded]` the question the team wishes nobody would ask.
 
-**Customer FAQ** (`## Customer FAQ`):
-- `[switch]` why this instead of what they use now.
-- `[safety]` their data, who stands behind it, what happens if it stops.
-- `[effort]` time to start, price or upkeep, what it plugs into.
-- `[rare]` a real but unusual case, a neighbouring use.
-- `[dreaded]` the question the team wishes nobody would put. Find it and ask it.
+**Internal FAQ** (`## Internal FAQ`): `[build]` the hardest part; `[last]` how it endures and the
+first users arrive; `[means]` who, how long, what is dropped; `[danger]` what kills it; `[why-us]`
+why this team, why now; `[avoided]` what the creator steers around.
 
-**Internal FAQ** (`## Internal FAQ`):
-- `[build]` the hardest part; what nobody knows how to do yet.
-- `[last]` how it pays or endures, how the first users arrive, why it holds against the others.
-- `[means]` who, for how long; what is dropped to make room.
-- `[danger]` what kills it, the worst outcome, legal exposure.
-- `[why-us]` why this team, why now; what it takes from other work.
-- `[avoided]` what the creator steers around.
-
-Adapt to `concept.md`: for a tool of one's own or an open project, price becomes effort to adopt,
-rivals become the current way, the company's survival becomes upkeep. A solo creator and a team are
-not asked the same things.
-
-**Answers** are honest ("not yet" is allowed), concrete (no "enterprise-grade") and believable.
-"We'll see" is not an answer: ask what would settle it and by when. An answer that exposes a gap:
-name it and let them class it in their words, to fix before launch, soon after, or to accept. They
-can add questions; they know the scary ones.
+Adapt to the concept kind (`forge.md`). Answers are honest ("not yet" is allowed), concrete; "we'll see" is not one: ask what would settle it and by when. A gap an answer exposes: they class it
+in their words, fix before launch, soon after, or accept.

package/dist/method/skills/test-idea/references/forge.md

@@ -1,36 +1,25 @@
 # The forge
 
-A dialogue that questions an idea until the creator can act on it, or drop it knowing why. What
-matters is a clearer head, not a file.
+**Concept.** Name the kind early and write it in the header (`concept:`); ask only if unclear. It
+decides who the reader is: `commercial` (a buyer: price, alternatives, first customers),
+`internal` (colleagues: effort to adopt, sponsor, upkeep; a tool for oneself is this), `open-source`
+(users and contributors: maintainer, licence), `community` (members: who steers, how it lasts).
+Begin with the person, not the product: who has the trouble, what they do today. With no reader
+after two or three exchanges, go back to the forge or to a round of ideas (skill `ideation`).
 
-**Start.** Get the idea, what they want from the session (understand it, test it, or improve it),
-and whether it is new or a change to a project that already has documents (`scope: change`, those
-documents in `links`). Ask only what is missing. First look for forge files with no `Outcome:` line
-and offer to resume one. Say they can steer (*attack*, *defend*, *switch roles*) and where the file
-is. Copy `assets/forge-template.md` to `.agentplugged/docs/ideas/forge-<slug>.md`.
+**Start.** The idea, what they want (understand, test, improve), new or a change to a project with
+documents (`scope: change`, those documents in `links`; they decide).
+Offer to resume a forge file with no `Outcome:` line. Say they can steer (*attack*, *defend*, *switch roles*). Copy `assets/forge-template.md` to `.agentplugged/docs/ideas/forge-<slug>.md`.
 
-**Questioning.** One question per turn, the one the others rest on first, with your own guess to
-accept or correct. Read what the documents already answer instead of asking. For a change to an
-existing project the documents decide: set the claim beside them, and if they disagree, settle that
-before anything else. When a word could mean several people (who uses it, who decides, who pays),
-have them pick one. After each settled branch, ask if anything still nags. No flattery, no easy
-agreement.
+**Questioning.** One question per turn, the one the others rest on first, with your guess to accept or
+correct. Read the documents instead of asking. No flattery, no easy agreement.
+Each turn, one persona fitted to the point (`personas.md`, played live) and one outsider you make up.
+*attack*: hunt contradictions and ways it fails, no approval until called off; *defend*: the best
+case; *switch roles*: swap.
 
-**Voices.** Each turn gives the floor to one persona fitted to the point (`personas.md`, played
-live, rotating) and to one outsider you make up. A chorus is not the goal.
-- *attack*: take the idea's side off; hunt contradictions, shaky assumptions, ways it fails; no
-  approval until they call it off.
-- *defend*: make the best case you can for it.
-- *switch roles*: swap sides.
+**Log.** After each beat a line under `## Log`, in their meaning, typed `[chose]`, `[bet]`
+(believed, unproved), `[gap]`, `[out]`, `[fixed]`, `[path]`.
 
-**Log.** After each beat, a line under `## Log`, in their meaning, opening with its type: `[chose]`,
-`[bet]` (believed, unproved), `[gap]`, `[out]` (ruled out), `[fixed]` (settled; reopened only if
-they say), `[path]`. A stopped forge resumes from these lines.
-
-**Close** with a line `Outcome:` under the title, delete the log, keep at most 40 lines:
-- *hardened*: `## Decisions`, and `## Rejected` (each option with its reason). The brief starts here:
-  decisions settled, rejected options out of scope with their reasons.
-- *killed*: `## Cause`, said plainly. Learning it early is a result.
-- *clearer*: `## Clearer`, what is now understood; nothing to hand on.
-
-What stays `[bet]` or `[gap]` becomes bets (`bets.md`).
+**Close** with `Outcome:` under the title, log deleted, at most 40 lines: *hardened* (`## Decisions`,
+`## Rejected` with reasons; the brief starts here), *killed* (`## Cause`), *clearer* (`## Clearer`).
+What stays `[bet]` or `[gap]` becomes bets (`personas.md`).

package/dist/method/skills/test-idea/references/personas.md

@@ -1,23 +1,20 @@
-# Personas
+# Personas and bets
 
-Compose 3 to 5 personas who would sink this idea, chosen for it, not from a fixed list: a
-demanding customer, the competitor, a skeptical investor, a user in a hurry, whoever pays or
-decides, someone who must trust it with their data. Give each a name, a stake and a question.
+Compose 3 to 5 personas who would sink this idea, chosen for it (a demanding customer, the
+competitor, a skeptical investor, whoever pays or decides), each with a name, a stake, a question.
+Played in turn, in a fresh context: two or three objections the idea cannot answer each. Merge: **strong objections**, **what holds**, **risky
+bets**; show that synthesis in a few lines.
 
-Played in turn, in a fresh context, each persona attacks the idea in its own voice:
+Report: `review.critique` as `.agentplugged/skills/critique-deliverable/references/format.md` says,
+with `kind: idea`, `lenses: ["personas"]`, `summary` the personas in one line; per objection `claim`
+the bet as a provable statement, `passage` a free label, `argument` the persona's reason, `proposal`,
+`proof`.
 
-1. Say what you would need to see to say yes. Say why you would walk away.
-2. Keep two or three objections the idea gives no answer to. Order by damage.
+## The bets
 
-Then, you:
-
-- Merge the attacks: the **strong objections** (several personas, or fatal ones), **what holds**
-  (attacks the idea answers), and the **risky bets** (what must be true and nobody knows yet).
-- Show the creator that synthesis, a few lines. The bets become the report.
-
-Report: `review.critique` as `references/format.md` of the skill `critique-deliverable`
-(`.agentplugged/skills/critique-deliverable/references/format.md`) says, with `kind: idea`,
-`lenses: ["personas"]`, `summary` the personas in one line. Per objection: `claim` the bet as a
-statement that can be proved or refuted, `passage` a short label of the part of the idea it
-aims at (not checked), `argument` the persona's reason, `proposal` and `proof` (what would
-show it true or false: an interview, a test, a number).
+Risky objections, `[bet]` or `[gap]` left after a forge, `[open]` questions and the `Soft` and
+`Breaks` items: one line each in the stack the engine returns. Gestures and calls as `.agentplugged/skills/critique-deliverable/references/gestures.md`, but offer two: **keep as
+a hypothesis** (`hypothesis`) or **drop** (`discard`, with their reason); `fix` stays possible, you
+change nothing without their say. A kept bet comes back with `hypotheses_due`; close it with their words only. Each report is sorted before it is made again (`critique_unsorted`). On a release
+(`kind: prfaq`) the `passage` is a heading of `prfaq.md` (`Release`, `Customer FAQ`, `Internal
+FAQ`), checked; on the idea, a free label.

package/dist/method/skills/test-idea/references/prfaq.md

@@ -1,33 +1,33 @@
 # The press release, written first
 
-Write as though the product already shipped, under a future date the creator picks, then the
-questions it would draw. Their words and facts come first; what they do not know stays a question,
-never filled in by you. The sections present show where you are: to resume, read them.
-
-**Four things first**: who the reader is, the trouble they feel, what it costs them, the rough
-answer (`concept.md`). Given all four at once, start drafting.
-
-**The release**, one aim per part:
-1. Headline: could the reader repeat it? Subheading: who gains, what changes.
-2. Opening: what is announced, for whom, why it matters to them.
-3. Problem: make the trouble felt, without the solution yet.
-4. Solution: what changes in the reader's day, not what was built.
-5. The creator's quote: the ambition behind the features.
-6. How it works, as the reader lives it.
-7. A reader's quote, marked `[imagined]`, never passed off as real.
-8. How to start (`concept.md`: how to take part, roll out or join).
-
-**Coaching.** For each part draft first, pick holes in your own draft aloud, ask them to sharpen it,
-then go one level deeper: a vague answer is asked for a case. If stuck, offer two or three concrete
-versions. They correct; you never overwrite.
-
-**Bars**, applied quietly: no jargon; no words that praise instead of showing (« unique »,
-« innovative », « cutting-edge », « game-changing »): give the fact; someone outside the field gets
-why it matters; each sentence survives "and then?"; no overselling, the FAQ would expose it. No
-figure without a source or `[assumption]`; a claim about rivals or the market with no source stays
-`[assumption]`, and you offer once to look it up (skill `deep-research`). No requirement identifier;
-`npx agentplugged docs check` reports nothing.
-
-Then `faq.md`, `verdict.md`. Once the verdict is in, the `document` checkpoint (`type: document`,
-low risk, no story, no blocks) cites `.agentplugged/docs/prfaq.md` with its `branch` and `blob_sha`.
-Later `write-positioning` starts from the validated release.
+Write as though the product shipped, under a future date they pick. Their words and facts first;
+what they do not know stays a question. Start from the reader (`forge.md`), their trouble, its cost,
+the rough answer.
+
+**The release**: headline (could the reader repeat it?) and subheading; opening; the problem felt,
+without the solution; the solution as the reader's day changes; the creator's quote; how it works;
+a reader's quote marked `[imagined]`, never passed off as real; how to start. Draft each part, pick holes in it
+aloud; they correct, you never overwrite.
+
+**Bars**: no jargon, no praise words (« unique », « innovative »): give the fact; no figure without a
+source or `[assumption]`; a claim about rivals or the market with no source stays `[assumption]`, and
+you offer once to look it up (skill `deep-research`); no requirement identifier; `npx agentplugged
+docs check` reports nothing.
+
+Then `faq.md` and the verdict. Once in, the `document` checkpoint (`type: document`, low risk,
+no story, no blocks) cites `.agentplugged/docs/prfaq.md` with its `branch` and `blob_sha`.
+
+## The verdict
+
+A last section `## Verdict`, three lines the engine checks:
+
+```
+- Holds: what is clear, honest and defensible.
+- Soft: what is promising but thin → what would firm it up.
+- Breaks: a real risk, a contradiction or a hole → what facing it would take.
+```
+
+Each item of `Soft` and `Breaks` ends with `→` and a next move; a category with nothing says `none`; labels follow the language (`Tient`, `Fragile`, `Casse`). The call is the
+worst category that has items, in one sentence; no score. `concept:` must be in the header or the
+closed release is refused. `Soft`, `Breaks` and `[open]` become bets (`personas.md`). Never decide
+for them what to do about a crack.

package/dist/method/skills/workshop/SKILL.md

@@ -7,28 +7,22 @@ metadata:
 ---
 # Workshop
 
-On the creator's ask: an agent or a skill of their own (their trade, their habits), or a look at one that
-exists, the method's or theirs; or Noah found that no active agent has the skill a request needs. Run under
-your own id (`agent: lou`), in their language. Four modes, they pick one. What is made is theirs, in
-`.agentplugged/agents/` or `.agentplugged/skills/`; the method shipped is never changed, a shipped agent
-or skill is only adjusted in `.agentplugged/overrides/`.
+On the creator's ask: an agent or a skill of their own, or a look at one that exists; or Noah found
+that no active agent has the skill a request needs. Run under your own id (`agent: lou`), in their
+language. They pick a mode. What is made is theirs, in `.agentplugged/agents/` or `.agentplugged/skills/`; the method shipped is never changed, only adjusted in `.agentplugged/overrides/`.
 
-1. `agent.status` (`working`). **Listen first**: invite them to say everything they have in mind (what it
-   is for, who it talks to, examples, what it must never do, existing files); ask one question at a time,
-   only for what is missing, with your recommendation. Never fill a gap with your own idea unasked.
-2. **Create** an agent or a skill: `references/create.md`. Draft the whole definition in their words and
-   show it; they correct it as often as they like.
-3. **Analyze** one that exists: `references/analyze.md`, one proposal at a time.
-3b. **Customise** a skill of the method (facts, steps, checks, a model for the output, a reviewer; the
-   product's or theirs alone), or say what can be: `references/customize.md`.
+1. `agent.status` (`working`). **Listen first**: invite them to say everything they have in mind; ask one
+   question at a time, only for what is missing. Never fill a gap unasked.
+2. **Create** or **Analyze** an agent or a skill: `references/create.md`. Draft the whole definition
+   in their words and show it.
+3. **Customise** a skill of the method: `references/customize.md`.
 4. **Check before you ask**: `agent.workshop` `check` with the `agent_create` or `agent_edit` you will
    request. The engine lists everything wrong at once and gives the cost; fix the list, check again.
    `references/rules.md` has the fields and what the engine refuses.
 5. **One gesture**: `guard.creator_action` with that action, `preview` shown whole as it is (it has the cost
-   in tokens), asked once. The engine writes the files and runs `sync`: one source, every AI tool.
+   in tokens), asked once. The engine writes the files and runs `sync`.
 6. **Prove it**: `agent.workshop` `verify` on the new `id` with two or three phrases they would say
-   (`triggers`); show what failed, if anything, and offer the fix as a new proposal. Its `evals` tells
-   whether the skill has behaviour cases; measuring them is `references/evaluate.md`, on their ask.
+   (`triggers`); offer the fix of what failed as a new proposal. Behaviour cases: `references/evaluate.md`.
 7. `agent.status` (`idle`), hand back to Noah.
 
 ## Never

package/dist/method/skills/workshop/references/create.md

@@ -1,45 +1,28 @@
-# Create an agent or a skill
-
-Agent or skill? An **agent** is someone: a persona, principles, a menu, who answers the creator. A **skill**
-is a way of doing one thing, a short procedure an agent calls from its menu. If it is one procedure, make a
-skill; if it is a role with several jobs, make an agent and give it skills.
-
-## Ask (one question at a time, skip what they already said)
-
-- **Agent**: the name and the job in one sentence; the domain (`product`, `ux`, `architecture`, `code`,
-  `quality`, `security`, `delivery`, `docs`, `creativity`, `marketing`, `sales`) and the phase (`framing`,
-  `planning`, `design`, `build`, `delivery`, `launch`); who they are (identity) and how they speak; what
-  they produce and where; how they work; **what they never do**; their principles; the menu: a short code,
-  what the item offers, and either the instruction or a skill it calls (`skill`).
-- **Skill**: when it is called, in one line (that line is the description); the steps in order; what it
-  produces and where; the rules it follows. Detail a step needs only sometimes goes in a **reference**
-  (`references`: a name and its lines), and the step says `references/<name>.md` where it is needed.
-
-## Keep it light (the creator pays for it in tokens)
-
-- The **description** is listed at every request of every session: at most 180 characters, and it says
-  *when* it is called (for what, in which phase, run by whom), not only what it is.
-- The body is read only when it runs: short steps, no repetition of what a capable model does unasked.
-  Long detail goes to a reference; a long menu instruction becomes a skill.
-- Look for an existing thing first (`agent.workshop` `analyze` on the closest): sharpen it rather than add a
-  second that reads the same.
-- Say the cost in your question: `check` returns it, the preview shows it.
-
-## The definition, in their words
-
-Write the lines as they said them, in their language; do not polish them into yours. Short sentences, one
-idea a line. For an agent: `overview` (who, for what), `produces`, `works`, `never` (at least one line: what
-the agent must not do, at least the actions only the creator takes), `principles`, `menu`, and if they gave
-them `identity`, `communication_style`, `persistent_facts`. For a skill: `steps`, `outputs`, `rules`, and
-`references` if any.
-
-A marketing or sales agent gets the publication boundary from the engine; you do not write it, and you
-cannot remove it. The same goes for the constitution, the permissions and the hooks: they are written for
-every tool by `sync`, outside the creator's text.
-
-## After the yes
-
-The engine writes `.agentplugged/agents/<id>/` (`SKILL.md`, `agent.yaml`) or `.agentplugged/skills/<id>/`
-(`SKILL.md`, `references/`) and runs `sync`: the same render as the shipped ones, for Claude Code, Codex,
-Cursor and Antigravity CLI. Then `verify` (its `evals` proposes behaviour cases: `references/evaluate.md`). To change it later, `analyze`, then a new `agent_edit`
-with the whole corrected `content`, shown and approved the same way.
+# Create, or analyze, an agent or a skill
+
+An **agent** is someone (persona, principles, menu); a **skill** is one procedure an agent calls.
+`analyze` the closest existing one first.
+
+## Create (one question at a time, skip what they said)
+
+- **Agent**: name and job; domain (`product`, `ux`, `architecture`, `code`, `quality`, `security`,
+  `delivery`, `docs`, `creativity`, `marketing`, `sales`) and phase (`framing`, `planning`, `design`,
+  `build`, `delivery`, `launch`); identity and voice; produces; works; **what it never does**;
+  principles; menu (code, description, instruction or `skill`).
+- **Skill**: when it is called in one line (that line is the description, 180 characters at most,
+  saying *when*); steps; outputs; rules. Detail needed only sometimes goes in a `references` file
+  named in a step as `references/<name>.md`.
+- The publication boundary of marketing and sales agents, the constitution, permissions and hooks
+  come from the engine and cannot be removed.
+- Their words, one idea a line. After the yes the engine writes the files and runs `sync`. Then `verify`.
+
+## Analyze
+
+`agent.workshop` `analyze` with the `id`: `findings` (`fix` before `tip`) and `cost`; the engine
+never rewrites. Say the cost, then the findings, the gravest first, **one at a time**: what, where
+(`field`), why, your change written out, the question. A declined finding is not raised again.
+- `agent_edit` (theirs): show the lines now and proposed, ask once; `guard.creator_action`
+  `agent_edit` with the **whole** corrected `content`.
+- `override` (a shipped agent, never edited): `.agentplugged/overrides/agents/<id>.yaml`, created
+  with `npx agentplugged agent edit <id>`; it adds, it cannot remove a rule.
+- `copy` (a shipped skill): `references/customize.md`, or their own skill. Then `verify` again.