rsc-universal 0.1.1

package/skills/press-kit/scripts/verify.sh

@@ -0,0 +1,161 @@
+#!/usr/bin/env bash
+#
+# verify.sh — structural guardrail for a drafted press release.
+#
+# WHAT IT DOES (read-only; never edits, moves, or writes a file)
+#   Static, network-free checks over ONE release file you point it at
+#   (a .md or .txt press release):
+#     1. Header line: a "FOR IMMEDIATE RELEASE" or "EMBARGOED UNTIL" line is
+#        present -> else FAIL. Reporters scan for it; missing = amateur.
+#     2. Dateline: a line shaped "CITY, ST, Month DD, YYYY —" (em dash, en dash,
+#        or "--") is present -> else FAIL. Anchors the story in time/place.
+#     3. Boilerplate: a line starting "About " is present -> else FAIL. The
+#        evergreen "About [Company]" paragraph every release closes with.
+#     4. End marker: a line that is exactly "###" or "-30-" -> else FAIL.
+#        Signals where the release ends.
+#     5. Contact: at least one email address (a press-contact block) -> else FAIL.
+#     6. Banlist (WARN): "thrilled to announce", "excited to announce",
+#        "world-class", "game-changer", "game changer", "revolutionary",
+#        "cutting-edge", "best-in-class" -> filler that weakens pickup.
+#     7. Embargo timezone (WARN): an EMBARGOED line with no recognizable timezone
+#        token (ET/PT/CT/MT/UTC/GMT/CET/CEST/EST/PST...) -> ambiguous embargo.
+#     8. Length (WARN): body word count over the ceiling (default 600 ~ two pages).
+#
+#   Checks 1–5 are hard failures. Banlist / embargo-TZ / length are warnings and
+#   do NOT fail the run unless --strict. A clean OR empty/missing-content file
+#   exits 0 — never a false failure on nothing.
+#
+# HOW TO RUN (inside YOUR project, not the skills repo)
+#   ./verify.sh release.md                 # hard checks + warnings
+#   ./verify.sh release.md --ceiling 500   # tighten the body word ceiling
+#   ./verify.sh release.md --strict        # treat warnings as failures (CI gate)
+#
+# EXIT CODES
+#   0  clean, warnings only (without --strict), or empty/missing-content file
+#   1  a hard failure (missing required marker) — or any warning under --strict
+#   2  bad usage (no file given, or file does not exist)
+#
+# Runs on stock macOS bash 3.2: no mapfile, no associative arrays, no bc.
+
+set -euo pipefail
+
+if [ -t 1 ]; then
+  RED=$'\033[31m'; GREEN=$'\033[32m'; YELLOW=$'\033[33m'; NC=$'\033[0m'
+else
+  RED=''; GREEN=''; YELLOW=''; NC=''
+fi
+
+warn_count=0; fail_count=0
+ok()   { printf '%s[ ok ]%s %s\n' "$GREEN"  "$NC" "$*"; }
+warn() { printf '%s[warn]%s %s\n' "$YELLOW" "$NC" "$*"; warn_count=$((warn_count + 1)); }
+fail() { printf '%s[fail]%s %s\n' "$RED"    "$NC" "$*"; fail_count=$((fail_count + 1)); }
+
+usage() { sed -n '2,46p' "$0" | sed 's/^# \{0,1\}//'; }
+
+FILE=""
+CEILING=600
+STRICT=0
+while [ $# -gt 0 ]; do
+  case "$1" in
+    -h|--help) usage; exit 0 ;;
+    --ceiling) CEILING="${2:-600}"; shift 2 ;;
+    --strict)  STRICT=1; shift ;;
+    -*) printf 'unknown option: %s\n' "$1" >&2; exit 2 ;;
+    *)  if [ -z "$FILE" ]; then FILE="$1"; fi; shift ;;
+  esac
+done
+
+if [ -z "$FILE" ]; then
+  printf 'usage: %s <release.md> [--ceiling N] [--strict]\n' "$(basename "$0")" >&2
+  exit 2
+fi
+if [ ! -f "$FILE" ]; then
+  printf 'no such file: %s\n' "$FILE" >&2
+  exit 2
+fi
+
+# Empty / whitespace-only file: nothing to check, never a false failure.
+if [ ! -s "$FILE" ] || ! grep -q '[^[:space:]]' "$FILE"; then
+  ok "empty or content-free file: nothing to verify"
+  exit 0
+fi
+
+# --- 1. Header line ---------------------------------------------------------
+if grep -qiE 'FOR IMMEDIATE RELEASE|EMBARGOED UNTIL' "$FILE"; then
+  ok "header line present (FOR IMMEDIATE RELEASE / EMBARGOED UNTIL)"
+else
+  fail "no header line — add 'FOR IMMEDIATE RELEASE' or 'EMBARGOED UNTIL [date time TZ]'"
+fi
+
+# --- 2. Dateline ------------------------------------------------------------
+# CITY[, ST], Month DD, YYYY followed by an em/en dash or --
+MONTHS='January|February|March|April|May|June|July|August|September|October|November|December'
+if grep -qE "[A-Z][A-Za-z.]+(,[ ]?[A-Z]{2})?,[ ]?(${MONTHS})[ ]+[0-9]{1,2},[ ]?[0-9]{4}[ ]*(—|–|--)" "$FILE"; then
+  ok "dateline present (CITY, ST, Month DD, YYYY —)"
+else
+  fail "no dateline — add 'CITY, ST, Month DD, YYYY —' before the lede"
+fi
+
+# --- 3. Boilerplate ---------------------------------------------------------
+if grep -qE '^[[:space:]]*(#+[[:space:]]*)?About ' "$FILE"; then
+  ok "boilerplate present (About [Company])"
+else
+  fail "no boilerplate — add an 'About [Company]' paragraph (<=100 words)"
+fi
+
+# --- 4. End marker ----------------------------------------------------------
+if grep -qE '^[[:space:]]*(###|-30-)[[:space:]]*$' "$FILE"; then
+  ok "end marker present (### / -30-)"
+else
+  fail "no end marker — close the body with '###' (or '-30-') on its own line"
+fi
+
+# --- 5. Contact (email) -----------------------------------------------------
+if grep -qE '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}' "$FILE"; then
+  ok "press-contact email present"
+else
+  fail "no contact email — add a Media Contact block with a real email address"
+fi
+
+# --- 6. Banlist (warn) ------------------------------------------------------
+BANLIST="thrilled to announce|excited to announce|world-class|game-changer|game changer|revolutionary|cutting-edge|best-in-class"
+hits=$(grep -inE "$BANLIST" "$FILE" || true)
+if [ -n "$hits" ]; then
+  while IFS= read -r line; do
+    [ -n "$line" ] && warn "filler phrase: ${line}"
+  done <<EOF
+$hits
+EOF
+else
+  ok "no banned filler phrases"
+fi
+
+# --- 7. Embargo timezone (warn) --------------------------------------------
+if grep -qiE 'EMBARGOED UNTIL' "$FILE"; then
+  if grep -iE 'EMBARGOED UNTIL' "$FILE" | grep -qiE '\b(ET|PT|CT|MT|EST|EDT|PST|PDT|CST|CDT|MST|MDT|UTC|GMT|CET|CEST|BST)\b'; then
+    ok "embargo line includes a timezone"
+  else
+    warn "embargo line has no timezone — an embargo without a TZ is ambiguous"
+  fi
+fi
+
+# --- 8. Body length (warn) --------------------------------------------------
+words=$(wc -w < "$FILE" | tr -d ' ')
+if [ "$words" -gt "$CEILING" ]; then
+  warn "release is ${words} words (> ${CEILING}); over two pages reads as too long"
+else
+  ok "length ${words} words (ceiling ${CEILING})"
+fi
+
+# --- Summary ---------------------------------------------------------------
+printf '\n'
+if [ "$fail_count" -gt 0 ]; then
+  printf '%s%d failure(s), %d warning(s)%s\n' "$RED" "$fail_count" "$warn_count" "$NC"
+  exit 1
+fi
+if [ "$STRICT" -eq 1 ] && [ "$warn_count" -gt 0 ]; then
+  printf '%s0 failures but %d warning(s) under --strict%s\n' "$YELLOW" "$warn_count" "$NC"
+  exit 1
+fi
+printf '%spassed: 0 failures, %d warning(s)%s\n' "$GREEN" "$warn_count" "$NC"
+exit 0

package/skills/pricing/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: pricing
+description: "Use when setting or resetting what a product or service charges and how it is packaged — choosing list price, margin floor, tiers, value metric, pricing model (flat/seat/usage/outcome/hybrid) and discount rules. Triggers: 'what should I charge', 'cómo pongo precio a esto', 'quin preu poso', 'design my pricing tiers', 'good better best packaging', 'we keep discounting away our margin', 'reprice because our AI compute costs jumped', 'localize price for other countries (PPP)', 'per-seat pricing is killing us', 'set a discount floor'. NOT issuing the actual bill (that is invoicing) and NOT implementing prices in a billing system (that is stripe)."
+tags: [pricing, packaging, margin, tiers, discounting, value-metric, willingness-to-pay, ppp]
+recommends: [invoicing, stripe, unit-economics, proposals, forecasting, sales-pipeline]
+origin: risco
+---
+
+# Pricing
+
+You decide two things here: the **number** (the list price) and the **shape** (packaging, tiers, model, and the floor underneath each price). You produce a *price card* — a table where every tier has a price, a cost, a value metric, and a margin that someone else can recompute and disagree with. That artifact is the deliverable; opinions without a recomputable margin are not.
+
+You do **not** charge the money (that is `../invoicing/SKILL.md`), build the billing objects (that is `../stripe/SKILL.md`), record revenue in the books, or validate the number against acquisition cost (that is `../unit-economics/SKILL.md`). Stay on the decision: what should this cost, and how is it boxed.
+
+## The spine — run it in this order
+
+The order matters because each step constrains the next. Skip a step and you set a price you cannot defend.
+
+1. **Floor (cost).** Compute fully-loaded unit cost (COGS + must-cover). Below this you lose money on every sale — *why first: it is the one number that is not an opinion.*
+2. **Ceiling (willingness-to-pay).** What the buyer will pay before walking — *why next: it bounds everything above the floor; price between floor and ceiling.*
+3. **Value metric.** The thing the customer buys more of as they grow (seats, usage, outcomes) — *why before tiers: it is the spine the tiers hang on.*
+4. **Model.** Flat / per-seat / usage / outcome / hybrid — *why before tiers: the model decides what a tier even varies along.*
+5. **Tiers.** Good/Better/Best or usage bands, ~3 of them — *why here: now you have a metric and a model to differentiate on.*
+6. **Discount floor.** Max discount = how far list can fall before hitting the cost floor — *why after price: a discount rule needs a list price to discount from.*
+7. **Localize (optional).** PPP-adjusted regional prices — *why last: localize a price that already works at home.*
+
+If you cannot answer step 1, stop and get the cost. Everything downstream is guesswork without it.
+
+## Margin math you must not get wrong
+
+Markup and margin use **different denominators**. Conflating them is the single most common pricing error.
+
+```text
+markup %  = (price - cost) / cost      <- denominator is COST
+margin %  = (price - cost) / price     <- denominator is PRICE
+```
+
+Reference points to sanity-check any card (verify.sh uses these):
+
+| Markup | Margin |
+|--------|--------|
+| 30%    | 23%    |
+| 43%    | 30%    |
+| 100%   | 50%    |
+
+A 50% markup is only a 33% margin. A 50% margin needs a 100% markup. They diverge fast.
+
+```text
+Bad:  cost $70, want "30% margin", apply 30% markup -> price $91
+      actual margin = (91-70)/91 = 23%. You undershot by 7 points.
+Good: cost $70, want 30% margin -> price = cost / (1 - 0.30)
+      = 70 / 0.70 = $100. Margin = (100-70)/100 = 30%. Correct.
+```
+
+The price-from-margin formula: `price = cost / (1 - target_margin)`. Memorize it; never apply a markup percentage when someone said "margin".
+
+## Pick the model
+
+Decide the model *before* drawing tiers — it determines what the tiers vary along.
+
+| Model | Use when | Value metric | Watch out |
+|-------|----------|--------------|-----------|
+| Flat | One persona, predictable use, simple sell | none (one price) | Leaves money on the table at the high end |
+| Per-seat | Value scales with users; collaboration tools | seats | Eroding — buyers cap seats and share logins; revenue stalls |
+| Usage / consumption | Value scales with volume; infra, API, AI | units consumed | Estimate anxiety + overage shock; needs a meter |
+| Outcome-based | You can attribute a result (resolutions, leads) | outcomes delivered | Attribution disputes; needs a credible counter |
+| Hybrid | Platform value + variable use (most AI products) | base + usage/outcome | Two dials to explain; keep the base legible |
+
+The market is moving off pure per-seat. ~85% of SaaS used some usage-based pricing by 2024 (up from ~30% in 2019), and Gartner expects ~40% of enterprise SaaS spend on usage/agent/outcome models by 2030. If you are defaulting to per-seat for an AI product, justify it.
+
+**AI-COGS caveat — the margin assumption changes.** Classic SaaS runs 80-90% gross margin. AI products run **50-60%** because every query has real compute cost. A "we'll just take 80% margin" plan is wrong for AI: the cost floor (step 1) becomes load-bearing, and you reprice when compute cost moves. See `references/pricing-models.md` for the outcome credit + overage formula (platform fee ≈ 2× delivery cost, e.g. $12K/yr incl. 100 resolutions then $5K per additional 100) and seat-compression math.
+
+## Package the tiers
+
+Good/Better/Best is the dominant SaaS shape; the average SaaS company offers ~3.5 tiers. Three is the safe default — enough to anchor, not enough to paralyze.
+
+- **Distinct on all three:** each tier must differ in features, limits, *and* price. If two tiers share limits, you have one tier with a typo.
+- **Value metric is the axis.** Tiers move along the value metric you picked in step 3 (more seats, more usage, more outcomes), not a random feature grab-bag.
+- **Anchor with the top tier.** The Best tier makes Better look reasonable; it is doing a job even if few buy it.
+- **Name the limit, not just the feature.** "10 projects" beats "projects" — a limit is what a buyer hits and upgrades on.
+
+```text
+Good     Better        Best
+$0/$X    $Y            $Z (anchor)
+3 seats  25 seats      unlimited seats
+1K calls 50K calls     500K calls + overage
+email    + Slack       + SSO, SLA, CSM
+```
+
+## Set the discount floor
+
+A discount needs a floor, not a vibe. Reps will give away the business if the only rule is "use judgment".
+
+- **Floor = COGS + must-cover cost** for that tier. Below it the deal loses money.
+- **Max discount % = (list − floor) / list.** This is the largest discount a rep can give without burning margin.
+- **No sign-off, no floor-break.** Discounting below the floor requires explicit approval, recorded. The floor is the deal-desk's hard stop.
+
+```text
+Tier "Better": list $1,000, cost floor $400
+max discount = (1000 - 400) / 1000 = 60%
+A rep offering 35% off ($650) is fine; 65% off ($350) breaks the floor -> sign-off.
+```
+
+## Localize (optional branch)
+
+Only if you sell across markets. Localizing beats raw FX conversion — PPP-adjusted regional pricing lifts revenue ~30% over straight currency math.
+
+- Start from **home list price × PPP factor** (World Bank / OECD), not the spot exchange rate.
+- **Charm vs round by market:** $99-style charm prices convert in US/DE/AU; round numbers are preferred in JP/CN/BR.
+- **Review quarterly to semiannually** — PPP and FX drift.
+- **Guard against VPN geo-arbitrage** with local payment-method / billing-address checks.
+
+The per-region rounding conventions, PPP sourcing, and arbitrage guards live in `references/localization.md` — most operators skip this branch, so it is offloaded.
+
+## Willingness-to-pay, fast
+
+You usually do not need a survey. Two paths:
+
+- **Cheap default:** raise the price until you feel friction (longer sales cycles, more "too expensive"). If nobody pushes back, you are underpriced.
+- **When the number is high-stakes:** run a **Van Westendorp** four-question survey — *at what price is this (1) too expensive to consider, (2) getting expensive but worth a look, (3) good value, (4) so cheap you doubt the quality.* The curve intersections give an acceptable price band and an optimal point. Use it before committing a number you cannot easily change.
+
+## Anti-patterns
+
+| Anti-pattern | Why it is wrong | Do instead |
+|--------------|-----------------|------------|
+| Applying markup % when someone said "margin" | 30% markup is only a 23% margin — you undershoot every time | `price = cost / (1 - margin)`; recompute, never assume |
+| Cost-plus only, ignoring willingness-to-pay | Leaves money on the table or prices below what buyers gladly pay | Floor from cost, ceiling from WTP, set price between |
+| Five+ tiers to "cover everyone" | Choice paralysis; nobody self-selects | ~3 tiers, distinct on features + limits + price |
+| Per-seat by default for an AI product | Seat revenue erodes and AI COGS breaks the 80% assumption | Pick the value metric first; consider usage/outcome/hybrid |
+| Discount "by judgment" with no floor | Reps give away the business deal by deal | Floor = COGS+must-cover; max discount = (list−floor)/list; below = sign-off |
+| Converting price by spot FX across markets | Mispriced vs local purchasing power; ~30% revenue left behind | PPP factor × home price; round per local convention |
+| Assuming 80-90% margin for AI compute | Real per-query COGS makes it 50-60%; you over-promise margin | Use the cost floor as load-bearing; reprice when compute moves |
+
+## The price card (the artifact)
+
+Emit a `price-card.csv` (or `.md` table / `.yaml`) — one row per tier:
+
+```csv
+tier,price,cost,value_metric,margin
+Good,29,11,seats,0.62
+Better,99,38,seats,0.62
+Best,299,110,seats,0.63
+```
+
+Rules the card must satisfy:
+- Every row has `price`, `cost`, `value_metric`, and a stated `margin`.
+- Stated margin matches recomputed `(price − cost) / price` within 0.5pt.
+- No `price <= cost` and no `price < floor`.
+- `margin` is a margin, not a markup (the classic conflation).
+
+`scripts/verify.sh <price-card>` recomputes every margin, flags any tier below its floor, and warns when a stated "margin" is actually a markup. Run it before you ship the card. It is read-only and exits 0 on an empty or clean card.
+
+## Siblings
+
+- Charge it / format the bill -> `../invoicing/SKILL.md`
+- Build products & prices in the billing system -> `../stripe/SKILL.md`
+- Validate the number against CAC / payback -> `../unit-economics/SKILL.md`
+- Put the price in front of one named buyer -> `../proposals/SKILL.md`
+- Project revenue from the price -> `../forecasting/SKILL.md`
+- Run the deal and pipeline stages -> `../sales-pipeline/SKILL.md`

package/skills/pricing/evals/README.md

@@ -0,0 +1,5 @@
+# Pricing evals — how to run
+
+These cases are routing and capability checks, not an automated test suite. `cases.yaml` lists prompts that **should** trigger this skill, prompts that should route to a named sibling instead, and one capability scenario with a `must_include` rubric. Run them by hand or against your live router: for each `should_trigger` / `should_not_trigger` prompt, confirm the router lands on the expected skill (and on the right sibling when it should not be `pricing`); for the capability scenario, run the skill end to end and check the output covers every rubric line — especially the margin-vs-markup math and the discount floor.
+
+This is separate from `scripts/verify.sh`. The evals check whether the skill *fires and reasons correctly*; `verify.sh` checks an *emitted price card* (recomputes each tier's margin, flags tiers below floor, warns on markup/margin conflation). Run `verify.sh` on any price card the skill produces; it is read-only and exits 0 on a clean or empty card.

package/skills/pricing/evals/cases.yaml

@@ -0,0 +1,44 @@
+skill: pricing
+
+should_trigger:
+  - prompt: "What should I charge for my new SaaS plan?"
+    why: Core list-price decision — the central job of this skill.
+  - prompt: "Help me design good/better/best tiers for my tool."
+    why: Packaging and tier design, the GBB shape this skill owns.
+  - prompt: "Our reps keep discounting and we lose money — set a floor."
+    why: Non-obvious — sounds like sales ops, but it is margin protection (discount floor = list−floor), which is a pricing decision, not a pipeline one.
+  - prompt: "Cómo pongo precio a mi servicio de consultoría?"
+    why: Spanish, services pricing — same decision (number + shape) for a service offer.
+  - prompt: "Our AI feature's compute cost jumped, we need to reprice."
+    why: Non-obvious COGS-driven reprice — the AI-margin caveat (50-60% vs 80-90%) makes the cost floor load-bearing here.
+  - prompt: "Should we go per-seat or usage-based?"
+    why: Pricing-model choice, an explicit step in the spine.
+  - prompt: "Quin preu poso al meu nou pla i com el empaqueto?"
+    why: Catalan — list price plus packaging, the two outputs of this skill.
+
+should_not_trigger:
+  - prompt: "Send the customer their invoice for last month."
+    route_to: invoicing
+    why: Charging the money and formatting the bill, not deciding the number.
+  - prompt: "Create the products and prices in Stripe."
+    route_to: stripe
+    why: Implementing prices in a billing system, not setting them.
+  - prompt: "Is our price profitable after CAC and payback?"
+    route_to: unit-economics
+    why: Validating the number across the acquisition funnel, not setting the number.
+  - prompt: "Write the priced proposal for Acme Corp."
+    route_to: proposals
+    why: A document for one named buyer, not the price-card decision.
+  - prompt: "Forecast next year's revenue at this price."
+    route_to: forecasting
+    why: Projecting revenue from a price, not choosing the price.
+
+capability:
+  - scenario: "Operator has a service with $40 fully-loaded delivery cost, wants a 60% gross margin, three tiers, and a discount floor so reps cannot give away the business."
+    must_include:
+      - "Computes price FROM margin, not markup: price = cost / (1 - 0.60) = $40 / 0.40 = $100 (so >= $100 for the base 60%-margin tier), not $40 x 1.60 = $64."
+      - "If the operator says '60% markup', flags the markup/margin conflation and shows it yields only a 37.5% margin ($40 x 1.60 = $64; (64-40)/64 = 0.375)."
+      - "Produces 3 distinct tiers that differ on features, limits, AND price, hung on a named value metric."
+      - "Sets a discount floor at or above the $40 COGS and states max discount % = (list − floor) / list."
+      - "Names a checkable price-card artifact (price-card.csv/.md/.yaml) and points to scripts/verify.sh."
+      - "Routes implementation to stripe and billing/invoicing to invoicing rather than doing them here."

package/skills/pricing/references/localization.md

@@ -0,0 +1,56 @@
+# Price localization (PPP) — mechanics
+
+Depth offloaded from SKILL.md. Most operators skip localization; read this when you actually sell across markets.
+
+## PPP, not spot FX
+
+Convert from purchasing power, not the exchange rate. A spot-FX conversion prices a $99 plan at whatever the dollar buys today in the local currency — which ignores that $99 of purchasing power is very different in São Paulo than in Zurich. PPP-adjusted regional pricing lifts revenue ~30% over straight currency conversion.
+
+```text
+local_price = home_list_price x PPP_factor(market)
+```
+
+Source the PPP factor from the **World Bank** or **OECD** PPP datasets (the conversion factor for GDP / private consumption). Do not invent factors; cite the table and date you used.
+
+## Per-region rounding
+
+After applying the PPP factor, round to the local price convention — a PPP-derived number like 73.41 is not a price you ship.
+
+| Market | Convention | Example |
+|--------|-----------|---------|
+| US, DE, AU | charm pricing (.99 / .95) | $99, €99 |
+| JP, CN, BR | round numbers preferred | ¥1,200, R$120 |
+
+Charm prices convert well in US/DE/AU; round numbers read as more trustworthy in JP/CN/BR. Match the local norm rather than forcing one global style.
+
+## FX vs PPP — when each
+
+- **PPP** sets the *strategic* local list price (what the plan should cost to feel equivalent).
+- **FX** only enters at the *billing* moment if you charge in the buyer's currency — and that is `../stripe/SKILL.md` / `../invoicing/SKILL.md` territory, not a pricing decision. Keep the FX conversion out of the price card.
+
+## Geo-arbitrage guards
+
+Cheaper regional prices invite VPN arbitrage — a buyer in a high-price market routing through a low-price one. Guard with:
+
+- Local **payment-method** checks (a card issued in the claimed region).
+- **Billing-address** verification against the region's price.
+- Flagging mismatches between IP region and payment/billing region.
+
+Do not rely on IP alone; it is the easiest signal to fake.
+
+## Review cadence
+
+Review regional prices **quarterly to semiannually**. Both PPP factors and FX drift, and a price set 18 months ago can be materially off purchasing power today. Put the review on a recurring calendar, not "when someone complains".
+
+## Sample regional table
+
+```text
+home list (US): $99
+market   PPP factor   PPP raw   rounded (local convention)
+DE       0.85         $84.15    €79  (charm)
+BR       0.45         $44.55    R$45 -> R$49 round-ish
+JP       0.95         $94.05    ¥1,400 (round)
+IN       0.30         $29.70    ₹2,400 (round)
+```
+
+Factors above are illustrative — pull live ones from World Bank/OECD before shipping.

package/skills/pricing/references/pricing-models.md

@@ -0,0 +1,55 @@
+# Pricing models — worked numbers
+
+Depth offloaded from SKILL.md. Read this when the model choice is non-obvious or the product is AI/usage/outcome-shaped.
+
+## Per-seat and why it erodes
+
+Per-seat ties revenue to user count. The failure mode is **seat compression**: as the buyer matures, they cap seats, share logins, and provision fewer accounts than people who actually use the product. Revenue plateaus while value (and your cost) keeps rising.
+
+```text
+Year 1: 50 seats x $20 = $1,000/mo
+Year 2: same team, buyer trims to 35 "active" seats = $700/mo
+        usage is flat-to-up, your cost is up, revenue is DOWN 30%.
+```
+
+If the value the customer gets does not actually scale with headcount, seats are the wrong metric. Move the variable dial to usage or outcomes and keep seats (if at all) as a small platform component.
+
+## Usage / consumption — metering pitfalls
+
+Usage pricing aligns price with value, but it introduces two buyer anxieties you must design around:
+
+1. **Estimate anxiety.** The buyer cannot predict the bill, so they hesitate to commit. Fix: offer a committed-use floor (prepaid bundle) plus overage, and a usage calculator.
+2. **Overage shock.** A spike produces a surprise invoice and a churn risk. Fix: alerts, soft caps, and the ability to pre-buy more before the overage rate kicks in.
+
+You also need a **meter you can defend** — the customer must be able to reconcile your number with theirs. If they cannot count the units, they will dispute the bill.
+
+## Outcome-based — the Bessemer starter formula
+
+Outcome pricing charges for a delivered result (a resolved ticket, a booked meeting, a closed lead). It only works when the outcome is **attributable** — you can prove the result was yours.
+
+Starter shape for an AI product:
+
+```text
+platform fee  ~= 2x your delivery cost   (covers infra + margin baseline)
+bundle a fixed number of outcome credits in the platform fee
+charge overage per block beyond the bundle
+
+example: $12,000 / year including 100 resolutions,
+         then $5,000 per additional 100 resolutions.
+```
+
+Sanity-check: the platform fee at ~2× delivery cost gives you a ~50% margin baseline before overage. Overage blocks should price at or above your marginal delivery cost per outcome, never below.
+
+## AI-COGS — why the margin assumption flips
+
+| | Classic SaaS | AI product |
+|--|--------------|------------|
+| Gross margin | 80-90% | 50-60% |
+| Marginal cost per use | ~0 | real compute per query |
+| Repricing trigger | rare | when compute cost moves |
+
+The consequence: cost-plus floors are load-bearing again. Run the cost floor (spine step 1) on real per-query compute, and revisit the price card whenever model/compute pricing shifts. Do not carry an 80% margin assumption into an AI plan — it will quietly turn a "profitable" tier into a loss.
+
+## Hybrid — keep it legible
+
+Most AI products land on hybrid: a base platform fee (predictable, covers fixed value) plus a usage or outcome dial (scales with value and cost). The risk is explaining two dials at once. Keep the base price legible and let the variable component be the thing that grows; do not make the buyer model two unknowns to estimate their bill.

package/skills/pricing/scripts/verify.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# verify.sh — validate a pricing price card. READ-ONLY: never writes or edits.
+#
+# Usage:   verify.sh [path/to/price-card.csv]
+# Default: ./price-card.csv if no path is given.
+#
+# Expects a CSV with a header containing the columns: tier,price,cost,value_metric,margin
+# (column order is detected from the header; extra columns are ignored).
+#
+# Checks per row:
+#   FAIL  stated margin disagrees with recomputed (price-cost)/price by > 0.5pt (0.005)
+#   FAIL  price <= cost (zero or negative margin)
+#   FAIL  value_metric empty
+#   WARN  stated "margin" actually equals the MARKUP (price-cost)/cost  (the classic conflation)
+# Exits 0 on a clean OR empty/missing card (no false failure); exits 1 if any FAIL fired.
+
+set -euo pipefail
+
+CARD="${1:-./price-card.csv}"
+
+if [ ! -f "$CARD" ]; then
+  echo "verify.sh: no price card at '$CARD' — nothing to check."
+  exit 0
+fi
+
+# Empty or header-only file -> clean by definition.
+data_rows="$(grep -cve '^[[:space:]]*$' "$CARD" || true)"
+if [ "${data_rows:-0}" -le 1 ]; then
+  echo "verify.sh: '$CARD' has no data rows — nothing to check."
+  exit 0
+fi
+
+awk -F',' '
+  function trim(s){ gsub(/^[ \t\r"]+|[ \t\r"]+$/, "", s); return s }
+  NR==1 {
+    for (i=1; i<=NF; i++) {
+      h=tolower(trim($i))
+      if (h=="tier")         ct=i
+      else if (h=="price")   cp=i
+      else if (h=="cost")    cc=i
+      else if (h=="margin")  cm=i
+      else if (h=="value_metric") cv=i
+    }
+    if (!cp || !cc || !cm || !cv) {
+      print "verify.sh: header missing required columns (need price,cost,margin,value_metric)."
+      exit 2
+    }
+    next
+  }
+  trim($0)=="" { next }
+  {
+    rows++
+    tier   = (ct ? trim($ct) : ("row " rows))
+    price  = trim($cp) + 0
+    cost   = trim($cc) + 0
+    stated = trim($cm) + 0
+    vmetric= trim($cv)
+
+    if (vmetric == "") {
+      printf "FAIL  %-12s value_metric is empty\n", tier
+      fail++
+      next
+    }
+    if (price <= cost) {
+      printf "FAIL  %-12s price (%.2f) <= cost (%.2f): zero or negative margin\n", tier, price, cost
+      fail++
+      next
+    }
+
+    margin = (price - cost) / price
+    markup = (price - cost) / cost
+    diff   = stated - margin; if (diff < 0) diff = -diff
+
+    # Conflation check: stated value matches markup but NOT margin.
+    md = stated - markup; if (md < 0) md = -md
+    if (md <= 0.005 && diff > 0.005) {
+      printf "WARN  %-12s stated %.1f%% equals the MARKUP, not the margin (true margin %.1f%%)\n", tier, stated*100, margin*100
+      warn++
+    } else if (diff > 0.005) {
+      printf "FAIL  %-12s stated margin %.1f%% != recomputed %.1f%% (price %.2f, cost %.2f)\n", tier, stated*100, margin*100, price, cost
+      fail++
+    } else {
+      printf "ok    %-12s margin %.1f%%  (price %.2f, cost %.2f, metric %s)\n", tier, margin*100, price, cost, vmetric
+    }
+  }
+  END {
+    if (rows == 0) { print "verify.sh: no data rows parsed — nothing to check."; exit 0 }
+    printf "verify.sh: %d tier(s), %d fail, %d warn\n", rows, fail+0, warn+0
+    if (fail+0 > 0) exit 1
+  }
+' "$CARD"