skilldrop-cli 1.1.3 → 1.3.0

package/README.md

@@ -80,7 +80,7 @@ Install one pack. Every role pack also brings `core` (intake, critique, review c
 ## How it works
 
 - **A skill produces one file you own.** Each ships a quality bar, named anti-patterns and acceptance evals, so the output is an artifact, not a conversation. See [every skill, by category](guides/reference/skill-catalogue.md).
-- **Loops order skills, and a gate decides when work moves on.** Five loops cover the lifecycle (`discover`, `design`, `build`, `release`, `operate`), plus the `ship-a-draft` wrapper for any document and `apply` for a job application. Each gate is a script, a review panel or a person, chosen by how expensive the mistake is to undo. See [the operating model](guides/explanation/operating-model.md) for every stage and gate on one page, [the loops, stage by stage](guides/reference/loops.md), and [why loops](guides/explanation/loops.md).
+- **Loops order skills, and a gate decides when work moves on.** Five loops cover the lifecycle (`discover`, `design`, `build`, `release`, `operate`), plus the `ship-a-draft` wrapper for any document and loops for jobs beside it, such as `research`, `comply`, `adopt` for a team starting with AI, `ship-agent` for an AI agent and `provision` for a Terraform change. Each gate is a script, a review panel or a person, chosen by how expensive the mistake is to undo. See [the operating model](guides/explanation/operating-model.md) for every stage and gate on one page, [the loops, stage by stage](guides/reference/loops.md), and [why loops](guides/explanation/loops.md).
 - **Measured, not asserted.** `run_bench.py` runs each acceptance eval with the skill and without it, in a sandbox, and reports the lift, a blind preference from two judges, and the cost per run. The results are published whether or not they flatter the skills. See [how skills are checked](https://sananthanarayan.github.io/skilldrop/evals/) and [RFC-0040](docs/rfcs/0040-skill-benchmark.md).
 - **Copy, never transform.** A skill is a plain `SKILL.md` folder in the [Agent Skills](https://agentskills.io) format, at `packs/<pack>/skills/<name>/`. What runs in your agent is byte-identical to what is reviewed here. There is no runtime, and the tooling has zero dependencies.
 - **Updates keep your edits.** `npx skilldrop-cli update` replaces files you haven't touched. For any file you changed, it leaves the new version beside it as `<file>.upstream`. See [upgrade installed skills](guides/how-to/upgrade-skills.md).

package/catalogue.json

@@ -109,7 +109,6 @@
       "skills": [
         "audience-profile",
         "slide-outliner",
-        "deck-builder",
         "exec-summary",
         "decision-log",
         "guide-builder",
@@ -131,12 +130,10 @@
       ]
     },
     "create-on-brand-collateral": {
-      "for": "Marketers · designers · anyone making a deck or flyer",
-      "description": "Make collateral that looks like it came from your team: capture the brand once, then build decks and print-ready flyers with your logo, colours and fonts.",
+      "for": "Marketers · designers · anyone making a deck",
+      "description": "Make collateral that looks like it came from your team: capture the brand once, then build decks with your logo, colours and fonts.",
       "skills": [
         "brand-kit",
-        "deck-builder",
-        "marketing-flyer",
         "slide-outliner"
       ]
     },
@@ -149,9 +146,7 @@
         "output-hygiene",
         "file-to-markdown",
         "md-to-docx",
-        "md-to-html",
         "md-to-xlsx",
-        "mermaid-render",
         "md-to-pptx",
         "md-to-confluence"
       ]
@@ -218,6 +213,10 @@
     "tech-comparison-matrix": { "in": "0.16.13", "why": "On evals it was never revised against, the agent without it did as well, and its weighted totals were wrong in 4 of 8 runs." },
     "db-schema-design": { "in": "0.16.13", "why": "On evals it was never revised against, the agent without it met as many checks (73% against 71%) and got types, time zones and constraints right unprompted." },
     "metric-definition": { "in": "0.16.13", "why": "On evals it was never revised against, the agent without it did everything the skill teaches unprompted and won 13 of 16 blind verdicts." },
-    "contribution-wizard": { "in": "0.16.13", "why": "It prescribed a skill layout this catalogue no longer uses and imposed it on other repos. To add a skill to skilldrop, follow AGENTS.md and run validate.py." }
+    "contribution-wizard": { "in": "0.16.13", "why": "It prescribed a skill layout this catalogue no longer uses and imposed it on other repos. To add a skill to skilldrop, follow AGENTS.md and run validate.py." },
+    "md-to-html": { "in": "1.2.0", "why": "On its held-out evals, in each of two trials and with both blind judges, the agent without it made the better page: the skill's script showed raw HTML as text and its security policy blocked embeds, and it adds no rule the agent breaks." },
+    "mermaid-render": { "in": "1.2.0", "why": "On its held-out evals, in each of two trials and with both blind judges, the agent without it fixed the same diagrams, ran the Mermaid CLI itself and said plainly what it had not rendered; the skill adds no rule it breaks." },
+    "marketing-flyer": { "in": "1.2.0", "why": "On its held-out evals, in each of two trials and with both blind judges, the agent without it built the whole flyer with placeholders where the skill stopped or used a generic template; it adds no rule the agent breaks." },
+    "deck-builder": { "in": "1.2.0", "why": "On its held-out evals the agent without it built the better deck in each of two trials; rebuilt rule-first, with its script able to run, it still lost on fresh evals (judges 2 and 1 of 4; 69% of checks against 81%).", "instead": "md-to-pptx" }
   }
 }

package/model-routing.json

@@ -234,10 +234,6 @@
       "tier": "light",
       "rationale": "Extracts decisions/owners/dates from notes. Pattern extraction; escalate on long transcripts via large-input rule."
     },
-    "deck-builder": {
-      "tier": "standard",
-      "rationale": "Shapes content, maps a brand template's layouts, and runs a script. Judgment, not hard reasoning."
-    },
     "delivery-metrics-report": {
       "tier": "standard",
       "rationale": "A stdlib script computes every number; the model maps columns, checks data quality and interprets weekly trends against fixed DORA definitions, which is bounded judgment."
@@ -335,10 +331,6 @@
       "tier": "standard",
       "rationale": "Methodology synthesis against a fixed decision tree and pitfall catalog. Grading-method and metric choices need judgment but are bounded; escalate via ambiguous-input on novel task types."
     },
-    "marketing-flyer": {
-      "tier": "standard",
-      "rationale": "Writes short copy to fit and fills a spec for a deterministic builder. Bounded generation."
-    },
     "mcp-pairing": {
       "tier": "standard",
       "rationale": "Matching a loop's stages to the context each needs and the narrowest access that provides it is bounded judgment over a short checklist."
@@ -351,10 +343,6 @@
       "tier": "standard",
       "rationale": "A stdlib script does the conversion; the model restructures the Markdown so it converts cleanly (heading levels, footnotes, HTML), reads each warning and explains the losses. Bounded editing, no open-ended generation."
     },
-    "md-to-html": {
-      "tier": "light",
-      "rationale": "A deterministic stdlib script does the conversion; the model picks options, fixes a few unsupported Markdown constructs and relays the script's warnings. Little judgment."
-    },
     "md-to-pptx": {
       "tier": "light",
       "rationale": "Mechanical conversion done by its script; the model only checks the outline maps to slides and reports what was dropped."
@@ -363,10 +351,6 @@
       "tier": "standard",
       "rationale": "A stdlib script types and writes the cells; the model shapes tables from the source (headings, units, one header row), decides whether formulas are safe to enable, and checks the per-sheet type counts against the data. Bounded, mostly mechanical judgment."
     },
-    "mermaid-render": {
-      "tier": "standard",
-      "rationale": "The script lints and renders deterministically, but fixing a broken diagram means reading the author's intent and rewriting syntax without changing nodes, edges or labels, and knowing when to ask instead."
-    },
     "migration-plan": {
       "tier": "standard",
       "rationale": "Phased plan synthesis with a strong template. Ordering judgment is bounded by the expand/migrate/contract pattern; escalate via ambiguous-input on contested, high-stakes cutovers."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skilldrop-cli",
-  "version": "1.1.3",
+  "version": "1.3.0",
   "description": "Portable AI-agent skills, measured against the agent without them. ADRs, PRDs, runbooks, decks and reviews, installable into Claude Code, Cursor, Kiro, and any IDE that takes custom instructions. One command per skill or per role-based pack.",
   "author": {
     "name": "Sanjay Ananthanarayan",

package/packs/ai-engineering/loops/adopt/LOOP.md

@@ -0,0 +1,120 @@
+---
+name: adopt
+description: Take an organisation from a pile of AI ideas to a first rollout wave its sponsor approved: the use cases ranked with a first slice, readiness scored against that slice, a usage policy covering the data the slice touches, and a cohort rollout whose first wave is the slice's users, with a gate that sends the slice back when a blocking gap stands in its way. Use when the user says "help us start using AI", "roll out AI across the team", "run the adopt loop", or has AI ideas, no policy and no rollout plan.
+---
+
+# adopt
+
+One first slice, from a list of ideas to a wave of people using it. The four skills each work
+alone; in order, each one narrows the next. Triage picks one use case, so readiness is scored
+against what that use case needs instead of against the whole organisation. Readiness names the
+gaps, so the policy covers the data the slice really touches. The rollout's pilot is the slice's
+own users, and its adoption gate is the observable triage said would prove or kill the slice.
+
+## Stages
+
+| # | Stage | Type | Skills | Gate |
+|---|---|---|---|---|
+| 1 | `triage` | generate | [`ai-use-case-triage`](../../skills/ai-use-case-triage/SKILL.md) | — |
+| 2 | `readiness` | verify | [`ai-readiness-assessment`](../../skills/ai-readiness-assessment/SKILL.md) | **G11** review |
+| 3 | `policy` | generate | [`ai-usage-policy`](../../skills/ai-usage-policy/SKILL.md) | — |
+| 4 | `rollout` | generate | [`ai-adoption-rollout`](../../skills/ai-adoption-rollout/SKILL.md) | — |
+| 5 | `sign-off` | gate | [`doc-critique`](../../../core/skills/doc-critique/SKILL.md) | **G11.1** human |
+
+## How to run this loop
+
+1. **Triage the ideas.** Run `ai-use-case-triage` on whatever the person brought: a brainstorm,
+   a backlog, interview notes. Save it as `triage.md`. Carry three things from it into every
+   later stage: the first slice (one workflow and the people who do it), the observable that
+   proves or kills it, and the time box.
+2. **Score readiness for the slice.** Run `ai-readiness-assessment` scoped to the slice's team
+   and the decision "can this slice start". Each dimension is read against what the slice
+   needs: Data is the data the slice reads, Tooling is the tool the slice uses, Process is the
+   review step the slice's output passes through. Save it as `readiness.md`.
+3. **Judge the slice at G11.** Ask three questions, then choose the verdict below:
+   - Does any gap the assessment ranks as blocking sit on something the slice needs?
+   - Can each remaining gap be closed inside the slice's time box, with an owner role named?
+   - Is there a review step where a person checks the slice's output before anyone acts on it?
+4. **On `REVISE`, change the slice, not the scores.** Return to `triage` with the blocking gap
+   as a constraint, and pick the highest-ranked candidate that does not need what is missing.
+   The not-yet list's promotion conditions say which one. Each return counts against the cap.
+5. **Write the policy for the slice's data.** Run `ai-usage-policy` for the slice's people,
+   naming every kind of data the slice puts into a tool (from triage and the Data line of
+   readiness). Every kind of data the slice touches gets a rule; a rule for data the slice
+   never touches stays out of this version. Save it as `policy.md`.
+6. **Plan the rollout from the slice.** Run `ai-adoption-rollout` with the slice's users as the
+   pilot cohort and triage's observable as the pilot's adoption gate. G11's conditions become
+   preconditions the pilot cannot open without. Save it as `rollout.md`.
+7. **Ask the sponsor at G11.1.** Run `doc-critique` over the policy and the rollout together,
+   then put the first wave, the conditions and the critique's open findings to the person who
+   sponsors the slice. Only they choose the verdict. In a non-interactive run, stop here and
+   write the decision they need to make; never record their verdict for them.
+8. **Hand over the plan, then the verdict.** Lead with the slice, who starts using it and when,
+   and what would end it. The scorecard, the policy and the cohort plan go underneath. Close
+   with each gate on its own line, `G11: <VERDICT>` and `G11.1: <VERDICT>` (or
+   `G11.1: awaiting <role>`), and one sentence of reasons.
+
+## Verdicts
+
+Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G11 emits:
+
+- `PROCEED`: no blocking gap sits on what the slice needs, and its output has a review step.
+- `PROCEED WITH CONDITIONS`: a gap sits on the slice but can close inside the time box, with
+  an owner role. Each condition travels into the rollout as a precondition for the pilot.
+- `REVISE`: a blocking gap sits on the slice and won't close inside the time box. Return to
+  `triage` with that gap as a constraint.
+- `RECONSIDER`: the gap blocks every candidate, such as no rule for what may go into any tool
+  or no tool access at all. Fixing it is the work, so the loop ends here with that gap's first
+  action and owner role.
+- `BLOCKED`: no candidates to triage, or no team the slice belongs to.
+
+G11.1 emits `PROCEED`, `PROCEED WITH CONDITIONS`, `REVISE` (back to `policy`, when the sponsor
+rejects a rule or a cohort) or `BLOCKED` (no sponsor named).
+
+On the cap-th `REVISE` at G11, emit `RECONSIDER`: three slices in a row hit blocking gaps, so
+the gaps are the work.
+
+## Non-interactive runs
+
+With no candidates, `ai-use-case-triage` emits `BLOCKED`; carry it through as the loop's
+verdict and run no further stages. Missing weights and readiness evidence degrade to the
+skills' own `[assumption]` and `[insufficient evidence]` tags. G11.1 always stops at the
+sponsor: write `G11.1: awaiting <role>` with the decision they face, never a verdict.
+
+## When a stage's skill is not installed
+
+Name the missing skill and skilldrop as its source, do the minimal inline version of that
+stage, and record that it ran degraded. A degraded `readiness` still scores Data, Tooling,
+Governance and Process against the slice with an evidence line each, because G11 can't be
+judged without them. Never skip G11 or G11.1.
+
+## Run log (opt-in)
+
+Only when the environment variable `SKILLDROP_LOOP_LOG` is set to a file path: after each
+gate's verdict, append one JSON line to that file. Nothing else is recorded, and nothing is
+sent anywhere. When the variable isn't set, or you can't read it, skip this section.
+
+```bash
+printf '%s\n' '{"ts":"2026-11-03T10:15:00Z","loop":"adopt","stage":"readiness","gate":"G11","verdict":"REVISE","round":1}' >> "$SKILLDROP_LOOP_LOG"
+```
+
+Fields: `ts` (UTC), `loop`, `stage`, `gate` (`null` for a stage without one), `verdict` (the
+gate's exact word), and `round` (1 for the first attempt, counting returns under the cap).
+The log holds verdicts only: never the use cases, the scores or the policy.
+`skilldrop loop-stats` summarises the file.
+
+## Quality bar
+
+- **Readiness is scored against the slice.** An organisation-wide score hides the one gap that stops the slice and flags gaps that stop nothing yet.
+- **A `REVISE` changes the slice.** It never re-scores a dimension upward to let the same slice through.
+- **The policy covers every kind of data the slice touches,** each restriction with what to do instead.
+- **The pilot is the slice's users, and its adoption gate is triage's observable.** A pilot of volunteers from elsewhere proves nothing about the slice.
+- **G11.1 is the sponsor's call.** The loop writes the decision they face; it never records their verdict.
+
+## Anti-patterns to avoid
+
+- ❌ **Scoring the whole company's readiness first.** The assessment then ranks gaps by how bad they look, not by what they block.
+- ❌ **Writing a policy for every tool and every kind of data before anything ships.** It is long, it is late, and nobody reads the part that matters to the pilot.
+- ❌ **Passing G11 with a blocking gap and a promise.** A gap that won't close inside the time box is a `REVISE`, however good the slice looks.
+- ❌ **A pilot gate that is "the pilot went well".** The gate is triage's observable, with its threshold and time box.
+- ❌ **Running all four skills before the first gate.** A policy and a rollout written for a slice that then fails G11 are thrown away.

package/packs/ai-engineering/loops/adopt/evals/eval_queries.json

@@ -0,0 +1,10 @@
+[
+  {"query": "help us start using AI in the finance team, we have ideas but no rules and no plan", "should_trigger": true},
+  {"query": "run the adopt loop on these AI use cases from the workshop", "should_trigger": true},
+  {"query": "we want to roll out AI across the support team: pick where to start, check we're ready, write the rules and plan the waves", "should_trigger": true},
+  {"query": "take this list of AI ideas to a first pilot our VP can sign off", "should_trigger": true},
+  {"query": "rank these twelve AI use cases by value and risk", "should_trigger": false},
+  {"query": "write an AI acceptable-use policy for our staff", "should_trigger": false},
+  {"query": "how far along is our engineering team with coding agents?", "should_trigger": false},
+  {"query": "design an eval harness for our support chatbot", "should_trigger": false}
+]

package/packs/ai-engineering/loops/adopt/evals/evals.json

@@ -0,0 +1,69 @@
+{
+  "loop_name": "adopt",
+  "evals": [
+    {
+      "id": "slice-first-then-readiness",
+      "prompt": "Run the adopt loop for our 40-person customer operations team at Larkspur Freight. Ideas from last week's workshop: (1) draft first replies to shipment-delay emails, (2) summarise call recordings for QA, (3) auto-approve refund claims under 50 GBP, (4) translate customs paperwork. We have Microsoft 365 with Copilot licences for 12 people; nobody has written any rules about what can go into it. Delay emails include customer names and tracking numbers; call recordings include card details read out loud. QA reviews 5% of calls today. The head of customer operations, Priya Anand, is the sponsor. Non-interactive: no follow-up questions.",
+      "assertions": [
+        "Runs ai-use-case-triage first and names one first slice with an observable that proves or kills it and a time box",
+        "Does not pick auto-approving refunds as the first slice, because its output reaches money without a review step",
+        "Scores readiness against the slice's needs (its data, the Copilot licences, its review step), not the whole company in general",
+        "Reaches a G11 verdict from PROCEED, PROCEED WITH CONDITIONS, REVISE, RECONSIDER or BLOCKED with the reasons",
+        "The policy has a rule for every kind of data the slice puts into a tool, each with what to do instead",
+        "The rollout's pilot is the slice's users and its adoption gate is triage's observable",
+        "Stops at G11.1 for the sponsor and writes the decision she faces, without recording a verdict for her",
+        "Does not invent tools, owners, regulations or figures the prompt did not give"
+      ]
+    },
+    {
+      "id": "blocking-gap-sends-the-slice-back",
+      "prompt": "Continuing the adopt loop. The readiness assessment for our first slice (summarising call recordings for QA) found that recordings contain card numbers read aloud, the recording system has no redaction, and the vendor says redaction ships in Q3 next year. Our time box for the slice was 6 weeks. The not-yet list from triage said: draft first replies to delay emails — promote when a reviewer can check the draft before it's sent (they can: agents already approve every outbound email). What now?",
+      "assertions": [
+        "Treats the redaction gap as blocking the slice and gives G11 REVISE, not PROCEED WITH CONDITIONS",
+        "Returns to triage rather than re-scoring readiness upward",
+        "Picks the delay-email drafting slice because its promotion condition is met",
+        "Re-scores readiness for the new slice before writing any policy",
+        "Counts the new slice's readiness check as round 2 under the cap of 3",
+        "Does not write a policy or rollout for the call-summary slice"
+      ]
+    },
+    {
+      "id": "blocked-without-candidates",
+      "prompt": "Run the adopt loop. We want to use more AI. Non-interactive, no follow-up questions.",
+      "assertions": [
+        "Emits BLOCKED and names what is missing: the candidate use cases and the team they belong to",
+        "Does not invent use cases, a team, or a sponsor",
+        "Does not run the readiness, policy or rollout stages",
+        "Says in plain words what it will produce once it has the candidates"
+      ]
+    },
+    {
+      "id": "adopt-first-wave-to-sign-off",
+      "held_out": "2026-11-03",
+      "prompt": "We want to start using AI at Pellmore but honestly it's a pile of ideas and nobody's written any rules. The ideas are in ai-ideas.md, company background is in org-context.md and last month's staff survey is staff-survey.csv. Can you run the adopt loop and get us to a first wave Ruth can sign off?",
+      "assertions": [
+        "Runs the stages in order (use-case triage, then readiness, then usage policy, then rollout, then sign-off), and each stage uses the previous one's output: readiness is scored against the named first slice, not the company in general",
+        "Triage ranks all seven ideas on value, feasibility and risk with the weights shown, names one first slice, and gives a not-yet list with the condition that would promote each",
+        "Gate G11 gives a verdict of PROCEED or PROCEED WITH CONDITIONS with an evidence line from the inputs per readiness score, and any conditions it sets show up in the policy or rollout",
+        "The usage policy covers the data the chosen slice touches (for delivery-date replies: customer names, addresses, phone numbers and order details from KitchenTrack), pairs every 'don't' with what to do instead, says what to do if data has already gone into a personal account, and addresses the personal-account use the survey found",
+        "The rollout's first wave is the chosen slice's users (the 14-person customer service team if the slice is delivery-date replies), fits within the 25 licensed seats, and has an adoption gate before the next wave opens; the comms plan answers the union rep's jobs question by saying what will not change",
+        "Stops at G11.1 with the doc-critique findings and asks Ruth Calloway to sign off; it does not record her approval itself or declare the wave approved",
+        "Does not invent tools, licences, owners, regulations or figures not in the inputs, such as a second AI vendor, a CRM, or headcounts that differ from org-context.md"
+      ]
+    },
+    {
+      "id": "adopt-sponsor-slice-blocked-by-client-data",
+      "held_out": "2026-11-03",
+      "prompt": "Margaret (our managing partner, she's sponsoring this) wants AI drafting replies to client tax queries to be the first thing we do. She's decided, so rank the rest of the ideas around it. Ideas are in ai-ideas.md, background is in firm-context.md. Run the adopt loop please, we'd like a rollout plan in front of her by the end of the month.",
+      "assertions": [
+        "Triage ranks all six ideas with the weights shown, records client tax-query replies as the first slice as the sponsor decided, and gives a not-yet list",
+        "Readiness is scored against the tax-query slice and names as blocking gaps that engagement-letter clause 9.2 and Schedule B allow no AI service without each client's prior written consent, and that no AI tool is licensed or approved, quoting or citing firm-context.md",
+        "Gate G11 does not pass: the verdict is REVISE, RECONSIDER or BLOCKED, not PROCEED, and it sends the slice back naming what would clear it (client consent or updated engagement letters and Schedule B, plus a contracted tool) or a slice that touches no client data, such as procedures-manual Q&A or the weekly guidance briefing",
+        "States the conflict with Margaret's decision plainly rather than silently swapping in a different slice",
+        "Does not write a usage policy or cohort rollout that treats client tax-query replies as cleared to go; if it reruns with a different slice, it scores readiness against that slice before writing the policy and rollout",
+        "Does not claim Margaret's approval or reach the G11.1 sign-off for the blocked slice",
+        "Does not invent an approved AI tool, a vendor agreement, client consent, or a regulation the inputs do not give"
+      ]
+    }
+  ]
+}

package/packs/ai-engineering/loops/adopt/evals/files/adopt-first-wave-to-sign-off/ai-ideas.md

@@ -0,0 +1,15 @@
+# AI ideas: collected from the staff forum and team leads, September 2026
+
+1. **Delivery-date replies (Customer service).** About 600 emails a week ask "where's my kitchen / when is my delivery". That's roughly 40% of the inbox. An assistant could draft the reply from the order status in KitchenTrack and the agent checks and sends. Submitted by the customer service team lead.
+
+2. **Kitchen renders from sketches (Design).** Turn a designer's hand sketch into a photo-style render to show the customer in the showroom. Today renders take a designer about half a day each. Submitted by two designers.
+
+3. **Showroom visit notes (Sales).** Summarise showroom visit notes into a follow-up email. Notes are handwritten in notebooks; there is no CRM. Submitted by a sales manager.
+
+4. **Invoice matching (Finance).** Match supplier invoices to purchase orders automatically. Around 900 invoices a month, matched by hand in the accounts package. Supplier price lists are commercially confidential. Submitted by the finance manager.
+
+5. **Machine breakdown prediction (Manufacturing).** Predict when the edge-banding and CNC machines will fail. Only 3 of 19 machines have sensors fitted; the rest have paper maintenance logs. Submitted by the factory engineer.
+
+6. **Staff handbook Q&A (HR).** A chatbot that answers holiday, sick-pay and shift-swap questions from the staff handbook. HR gets about 40 of these a week. Submitted by HR.
+
+7. **Product descriptions (Marketing).** Write website product descriptions from the spec sheets for the 2027 range (about 120 products). Submitted by marketing.

package/packs/ai-engineering/loops/adopt/evals/files/adopt-first-wave-to-sign-off/org-context.md

@@ -0,0 +1,27 @@
+# Pellmore Kitchens Ltd: background for the AI work
+
+## The company
+- Designs, makes and fits fitted kitchens. 240 staff across the factory and the head office/showroom.
+- Teams: Manufacturing 130, Operations and logistics 26, Sales 22, Design 18, Customer service 14, Finance 9, Marketing 8, Leadership 6, HR 4, IT 3.
+
+## Sponsor
+- Ruth Calloway, Operations Director, sponsors the AI work and signs off the first rollout wave. She wants a first wave live before the January peak.
+
+## Tools
+- Office suite with its enterprise AI chat assistant, licensed since June 2026 for 25 seats. The contract says prompts and files are not used to train models and data is held in the UK/EU. Nobody has been given a seat yet; IT holds all 25.
+- KitchenTrack, the in-house order system. Holds customer names, delivery addresses, phone numbers, email addresses, order lines, prices paid and delivery slots. No API; IT runs a nightly CSV export of order status.
+- Accounts package for finance; no AI features switched on.
+
+## Data
+- Customer personal data lives in KitchenTrack and the customer service inbox.
+- Supplier price lists are commercially confidential under the supplier agreements.
+- Staff HR records are held by HR only.
+- The finance manager is also the company's data protection lead (part of the role). There is a data protection policy (2023). There is no AI policy of any kind.
+
+## What people are worried about
+- The staff survey (staff-survey.csv) found people already using personal AI accounts at work, including pasting customer emails into chatbots on their phones.
+- The customer service team's union rep has asked whether this is about cutting jobs in customer service.
+- Finance is worried about supplier pricing leaking.
+
+## Skills and support
+- No AI training has been run. IT (3 people) can give two days a month to support a rollout.

package/packs/ai-engineering/loops/adopt/evals/files/adopt-first-wave-to-sign-off/staff-survey.csv

@@ -0,0 +1,11 @@
+team,respondents,used_ai_at_work_last_month,used_personal_account_for_work,wants_training,worried_about_jobs
+Customer service,12,9,8,11,7
+Sales,15,6,5,9,2
+Design,14,10,7,8,3
+Finance,8,2,1,5,1
+Operations and logistics,10,1,1,4,2
+Marketing,6,6,3,4,1
+Manufacturing,21,0,0,6,9
+HR,4,1,0,3,0
+Leadership,5,3,2,2,0
+IT,3,3,1,0,0

package/packs/ai-engineering/loops/adopt/evals/files/adopt-sponsor-slice-blocked-by-client-data/ai-ideas.md

@@ -0,0 +1,13 @@
+# AI ideas from the October partners' meeting
+
+1. **Client tax-query replies.** Draft replies to client emails asking about their tax position, using the client's file (prior returns, correspondence, working papers). Roughly 350 such emails a month across the tax team; each takes a manager 20 to 40 minutes. Margaret's priority.
+
+2. **Bank statement extraction.** Pull transactions from the PDF bank statements clients send in, ready for bookkeeping. About 1,100 statements a month.
+
+3. **Client call notes.** Record and summarise client calls into the practice management system.
+
+4. **Procedures manual Q&A.** Answer staff questions from the firm's internal procedures manual (onboarding, filing deadlines process, how to raise an invoice). The manual is 140 pages and nobody can find anything in it. No client data in it.
+
+5. **Weekly guidance briefing.** Summarise the week's published tax guidance updates into a one-page staff briefing. Uses only public material.
+
+6. **Newsletter drafts.** Draft the quarterly client newsletter from the partners' bullet points.

package/packs/ai-engineering/loops/adopt/evals/files/adopt-sponsor-slice-blocked-by-client-data/firm-context.md

@@ -0,0 +1,23 @@
+# Corrow Lane Accounting LLP: background
+
+## The firm
+- 58 people: 6 partners, 14 in the tax team, 21 in accounts and bookkeeping, 9 in payroll, 8 in practice support (admin, IT, marketing).
+- Around 1,900 clients: sole traders, small companies and some high-net-worth individuals.
+
+## Sponsor
+- Margaret Ilsley, managing partner, sponsors the AI work and will sign off any rollout. She has decided client tax-query replies come first.
+
+## Systems
+- Client files live on an on-premises file server and in LedgerDesk, the practice management system. LedgerDesk has no AI features and no export API.
+- Email is hosted by our email provider.
+- No AI tool is licensed or approved. In August 2026 the IT manager blocked two public chatbot sites after a junior was seen pasting a client's payslip into one.
+
+## Client contracts
+- Every client signs our standard engagement letter. Clause 9.2 reads: "We will not disclose your information to any third party, or process it using third-party services other than those listed in Schedule B, without your prior written consent."
+- Schedule B lists three services: our email hosting provider, our payroll bureau, and our cloud backup provider. Nothing else.
+- Engagement letters are reissued each April.
+
+## Other
+- Our professional indemnity insurer's renewal questionnaire, due January 2027, asks whether we use AI on client work and how it is controlled.
+- Practice support has one IT manager and no one with AI experience.
+- Staff survey (informal, September): 31 of 58 said they would use an AI tool if the firm approved one.

package/packs/ai-engineering/loops/adopt/loop.json

@@ -0,0 +1,53 @@
+{
+  "$comment": "RFC-0069. AI ideas to a first rollout wave a sponsor approved. Readiness is scored against the first slice, not the whole organisation, because a gap only blocks the use cases that need what is missing; the gate sits there so a slice that needs it goes back to triage before anyone writes a policy for it.",
+  "name": "adopt",
+  "version": "0.1.0",
+  "description": "Take an organisation from a pile of AI ideas to a first rollout wave its sponsor approved: the use cases ranked with a first slice, readiness scored against that slice, a usage policy covering the data the slice touches, and a cohort rollout whose first wave is the slice's users, with a gate that sends the slice back when a blocking gap stands in its way. Use when the user says \"help us start using AI\", \"roll out AI across the team\", \"run the adopt loop\", or has AI ideas, no policy and no rollout plan.",
+  "entrypoint": "LOOP.md",
+  "kind": "loop",
+  "cap": 3,
+  "stages": [
+    {
+      "id": "triage",
+      "type": "generate",
+      "intent": "Rank the candidate use cases on value, feasibility and risk with the weights shown, and name one first slice with the observable that would prove or kill it.",
+      "skills": ["ai-use-case-triage"]
+    },
+    {
+      "id": "readiness",
+      "type": "verify",
+      "intent": "Score readiness against what the first slice needs, and judge whether any blocking gap stands between the slice and its first users.",
+      "skills": ["ai-readiness-assessment"],
+      "gate": {
+        "id": "G11",
+        "kind": "review",
+        "verdicts": ["PROCEED", "PROCEED WITH CONDITIONS", "REVISE", "RECONSIDER", "BLOCKED"],
+        "revise_to": "triage"
+      }
+    },
+    {
+      "id": "policy",
+      "type": "generate",
+      "intent": "Write the usage rules for the people in the slice, covering every kind of data the slice puts into a tool, each restriction paired with what to do instead.",
+      "skills": ["ai-usage-policy"]
+    },
+    {
+      "id": "rollout",
+      "type": "generate",
+      "intent": "Plan the cohorts, enablement, champions and comms, with the slice's users as the pilot and the slice's observable as the pilot's adoption gate.",
+      "skills": ["ai-adoption-rollout"]
+    },
+    {
+      "id": "sign-off",
+      "type": "gate",
+      "intent": "The sponsor approves the first wave, with the policy and the readiness conditions it opens under.",
+      "skills": ["doc-critique"],
+      "gate": {
+        "id": "G11.1",
+        "kind": "human",
+        "verdicts": ["PROCEED", "PROCEED WITH CONDITIONS", "REVISE", "BLOCKED"],
+        "revise_to": "policy"
+      }
+    }
+  ]
+}

package/packs/ai-engineering/loops/ship-agent/LOOP.md

@@ -0,0 +1,128 @@
+---
+name: ship-agent
+description: Take an AI agent from an idea to a launch a person signed: the loop spec with its exit criteria and cap, the spend caps per stage, a threat model where every lethal-trifecta path has an architectural fix, an eval harness with its pass bar set before the first run, and a review of the real agent configuration before launch, with a gate that sends the design back when a path to exfiltration stays open. Use when the user says "we're building an agent", "design and ship this agent safely", "run the ship-agent loop", or wants an agent taken from design to launch with its risks and evals settled.
+---
+
+# ship-agent
+
+One agent, from a described job to a launch its owner signed. Each skill works alone; in order,
+each one reads the last one's output. The loop design names every stage and tool, so the budget
+caps real stages and the threat model inventories real capabilities. The threat model's attacks
+become the eval harness's adversarial cases. The launch review reads the configuration the team
+actually built against the capabilities the threat model allowed, which no design document can
+check about itself.
+
+## Stages
+
+| # | Stage | Type | Skills | Gate |
+|---|---|---|---|---|
+| 1 | `design` | generate | [`agent-loop-design`](../../skills/agent-loop-design/SKILL.md), [`subagent-design`](../../skills/subagent-design/SKILL.md) | — |
+| 2 | `budget` | generate | [`agent-budget`](../../skills/agent-budget/SKILL.md) | — |
+| 3 | `threat` | verify | [`agent-threat-model`](../../skills/agent-threat-model/SKILL.md) | **G12** review |
+| 4 | `evals` | generate | [`llm-eval-harness`](../../skills/llm-eval-harness/SKILL.md) | — |
+| 5 | `launch` | gate | [`agent-config-review`](../../skills/agent-config-review/SKILL.md) | **G12.1** human |
+
+## How to run this loop
+
+1. **Design the loop.** Run `agent-loop-design` on the job. Run `subagent-design` after it only
+   when the job fans out across agents; a single agent skips it. Save the spec as `design.md`.
+   Carry two things into every later stage: the tool and data list, and the done-condition.
+2. **Cap the spend.** Run `agent-budget` on the design's stages. Each stage gets a tier, a token
+   cap and an abort rule; a stage the design doesn't have gets no budget. Save it as
+   `budget.md`.
+3. **Threat-model the design.** Run `agent-threat-model` with the design's tool and data list
+   as the capability inventory. A capability the design implies but doesn't list is modelled at
+   its widest plausible scope and tagged `[assumption]`. Save it as `threat.md`.
+4. **Judge the design at G12.** Ask three questions, then choose the verdict below:
+   - Does every 🟥 path (private data, untrusted content and a way out, in one context) have an
+     architectural fix, not a prompt instruction?
+   - Does any fix contradict the design, such as a tool removed that a stage needs?
+   - Is every residual risk owned by a named role?
+5. **On `REVISE`, change the design.** Return to `design` with the open path and its fix: split
+   the context, drop the tool, or put a human gate on the outbound step. Re-run `budget` and
+   `threat` on the new design. Each return counts against the cap.
+6. **Design the evals.** Run `llm-eval-harness` with the design's done-condition as the task.
+   Every attack in the threat model's sweeps becomes an adversarial case in the critical
+   subset, which must stay at 100%. The pass bar and regression gate are fixed now. Save it as
+   `evals.md`.
+7. **Stop while the team builds.** The loop has produced the design, budget, threat model and
+   eval plan. Hand them over and stop until the team has a built agent, its configuration
+   files and one eval run. Resume at `launch` when they bring them.
+8. **Review the launch at G12.1.** Run `agent-config-review` on the real configuration, then
+   check each granted capability against `threat.md`: a grant the threat model did not allow
+   is a finding, however harmless it looks. Put the review verdict, the eval result against
+   the pass bar, and every residual risk in front of the agent's owner. Only they choose the
+   verdict. In a non-interactive run, stop and write the decision they face.
+9. **Hand over the decision, then the working.** Lead with what the agent will be able to do,
+   what it can't, and what still stands between it and launch. The documents go underneath.
+   Close with each gate on its own line, `G12: <VERDICT>` and `G12.1: <VERDICT>` (or
+   `G12.1: awaiting <role>`), and one sentence of reasons.
+
+## Verdicts
+
+Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G12 emits:
+
+- `PROCEED`: every 🟥 path has an architectural fix, no fix contradicts the design, and every
+  residual risk has an owner role.
+- `PROCEED WITH CONDITIONS`: the fixes are designed but one depends on something unverified,
+  such as a sandbox's egress rule. The condition goes into the eval plan as a case and into the
+  launch review as a check.
+- `REVISE`: a 🟥 path is left open, or its only fix is a prompt instruction. Return to
+  `design`.
+- `RECONSIDER`: the job can't be done without all three legs of the trifecta in one context,
+  such as an agent that must read untrusted email and send email on its own. The job needs a
+  person in the loop or a different scope, so the loop ends here.
+- `BLOCKED`: no tool or data list can be established.
+
+G12.1 emits `PROCEED`, `PROCEED WITH CONDITIONS`, `REVISE` (back to `threat`, when the built
+configuration grants what the threat model didn't allow, or the eval misses the pass bar) or
+`BLOCKED` (no configuration, no eval run, or no owner).
+
+On the cap-th `REVISE` at G12, emit `RECONSIDER`: three designs in a row left a path open, so
+the job's scope is the problem.
+
+## Non-interactive runs
+
+With no tool or data list, `agent-threat-model` emits
+`BLOCKED: need the agent's tool/permission inventory`; carry it through and run no further
+stages. Before the agent is built, the loop ends after `evals` with
+`G12.1: awaiting the built agent's configuration and one eval run`. G12.1 never passes without
+its owner.
+
+## When a stage's skill is not installed
+
+Name the missing skill and skilldrop as its source, do the minimal inline version of that
+stage, and record that it ran degraded. A degraded `threat` still classifies every content
+source as trusted or untrusted and lists each path that joins all three legs, because G12
+can't be judged without them. Never skip G12 or G12.1.
+
+## Run log (opt-in)
+
+Only when the environment variable `SKILLDROP_LOOP_LOG` is set to a file path: after each
+gate's verdict, append one JSON line to that file. Nothing else is recorded, and nothing is
+sent anywhere. When the variable isn't set, or you can't read it, skip this section.
+
+```bash
+printf '%s\n' '{"ts":"2026-11-03T10:15:00Z","loop":"ship-agent","stage":"threat","gate":"G12","verdict":"REVISE","round":1}' >> "$SKILLDROP_LOOP_LOG"
+```
+
+Fields: `ts` (UTC), `loop`, `stage`, `gate` (`null` for a stage without one), `verdict` (the
+gate's exact word), and `round` (1 for the first attempt, counting returns under the cap).
+The log holds verdicts only: never the design, the capabilities or the findings.
+`skilldrop loop-stats` summarises the file.
+
+## Quality bar
+
+- **The threat model inventories the design's tools,** not a generic agent's. A capability the design implies but doesn't list is modelled at its widest scope.
+- **G12 passes only on architectural fixes.** "The prompt tells it not to" is not a fix for an open path.
+- **Every threat-model attack is an eval case in the critical subset,** and the pass bar is set before the first run.
+- **The launch review checks the built configuration against the threat model.** A grant the model didn't allow is a finding.
+- **G12.1 is the owner's call.** The loop writes the decision they face; it never records their verdict.
+
+## Anti-patterns to avoid
+
+- ❌ **Threat-modelling before the design exists.** The model then inventories capabilities nobody chose, and misses the ones the design adds.
+- ❌ **Fixing an open path with a system-prompt rule.** Injected content outranks the prompt that was meant to stop it.
+- ❌ **Setting the pass bar after the first eval run.** A bar set after seeing results is chosen to pass.
+- ❌ **Reviewing the configuration the design describes instead of the one the team built.** The gap between them is what the launch review is for.
+- ❌ **Skipping the budget because the agent is small.** A loop with no token cap and no abort rule is how a small agent sends a large bill.

package/packs/ai-engineering/loops/ship-agent/evals/eval_queries.json

@@ -0,0 +1,10 @@
+[
+  {"query": "we're building an agent that reads our Jira tickets and opens PRs, take it from design to launch safely", "should_trigger": true},
+  {"query": "run the ship-agent loop on this support-inbox agent", "should_trigger": true},
+  {"query": "design this agent, cap what it can spend, threat-model it and set up the evals before we build it", "should_trigger": true},
+  {"query": "we built the agent, check its config against the threat model and tell the owner if it can launch", "should_trigger": true},
+  {"query": "threat-model this MCP setup for prompt injection", "should_trigger": false},
+  {"query": "is our .claude/settings.json safe?", "should_trigger": false},
+  {"query": "should this be one agent or several?", "should_trigger": false},
+  {"query": "help us start using AI across the company", "should_trigger": false}
+]