rsc-universal 0.1.1

package/skills/forecasting/references/methods-cheatsheet.md

@@ -0,0 +1,94 @@
+# Methods cheatsheet
+
+One page per method: when to use it and the exact statsforecast (Nixtla, v2.0.3)
+call. `m` = seasonal period (12 monthly, 7 daily-with-weekly-season, 52 weekly),
+`h` = horizon. Always include `level=[80]` or `[95]` for an interval.
+
+## Naive
+
+Repeat the last observed value. The cheapest baseline; the bar for non-seasonal
+series. Use when the series has no trend and no seasonality.
+
+```python
+from statsforecast.models import Naive
+Naive()
+```
+
+## SeasonalNaive
+
+Repeat the value from one season ago (last December → this December). The bar for
+any seasonal series, and the **only** thing you should ship when you have fewer than
+2 full seasonal cycles of history. Do not fit a model on that little data.
+
+```python
+from statsforecast.models import SeasonalNaive
+SeasonalNaive(season_length=m)
+```
+
+## Moving average / simple exponential smoothing (SES)
+
+Flat series with no trend or season. SES weights recent observations more. Honest
+for a noisy mean; do not use SES on intermittent demand (see Croston). `AutoCES`
+auto-tunes the smoothing.
+
+```python
+from statsforecast.models import AutoCES
+AutoCES(season_length=m)
+```
+
+## ETS (error-trend-season)
+
+The workhorse for business series with trend and/or seasonality. `AutoETS` selects
+the additive/multiplicative components automatically — no manual order picking.
+Strong, fast, well-calibrated intervals. Usually try this first after the baseline.
+
+```python
+from statsforecast.models import AutoETS
+AutoETS(season_length=m)
+```
+
+## Theta
+
+A simple, robust method that decomposes the series into theta-lines. Often wins on
+monthly business data and is cheap to run. A great cheap default alongside ETS.
+
+```python
+from statsforecast.models import AutoTheta
+AutoTheta(season_length=m)
+```
+
+## ARIMA
+
+Use when errors are autocorrelated and seasonality is strong and known. `AutoARIMA`
+searches orders automatically and is roughly 20x faster than pmdarima. More flexible
+than ETS but slower and easier to overfit on short history — let the backtest, not
+the AIC alone, decide whether it earns its place over ETS.
+
+```python
+from statsforecast.models import AutoARIMA
+AutoARIMA(season_length=m)
+```
+
+## Croston / SBA / TSB — intermittent demand
+
+Sporadic demand with many zero periods (slow-moving SKUs, spare parts). SES is
+provably inappropriate here (Croston 1972): it reacts to zeros as if they were
+demand. Croston forecasts demand size and inter-arrival interval separately; SBA
+(Syntetos–Boylan 2001) debiases Croston; TSB handles obsolescence. `CrostonOptimized`
+auto-tunes; `IMAPA`/`ADIDA` aggregate-then-disaggregate. An Auto classifier can pick
+between Croston/SBA/SES by demand pattern.
+
+```python
+from statsforecast.models import CrostonOptimized, CrostonSBA, TSB
+CrostonOptimized()           # default optimized Croston
+CrostonSBA()                 # Syntetos–Boylan bias correction
+TSB(alpha_d=0.2, alpha_p=0.2)  # demand-probability variant, handles obsolescence
+```
+
+## Hierarchy reconciliation
+
+When SKU forecasts must sum to a category/region total, forecast each level then
+reconcile so they are coherent. Bottom-up is the simplest; MinT (minimum trace) is
+the statistically efficient default and is available via Nixtla's `hierarchicalforecast`
+package (`pip install hierarchicalforecast`). Forecast all levels, then apply a
+reconciler — do not just trust independent per-SKU forecasts to add up.

package/skills/forecasting/scripts/verify.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# verify.sh — validate forecast artifacts produced by the forecasting skill.
+#
+# Read-only by default: it inspects forecast CSV/Parquet-as-CSV files and checks
+# they honor the deliverable contract. It writes nothing and changes nothing.
+#
+# A valid forecast artifact must:
+#   1. have a header containing `ds` and `forecast`
+#   2. have at least one interval column (lo/hi, or *-lo-*/*-hi-* from statsforecast)
+#   3. have at least one data row (the horizon)
+# An accompanying accuracy readout (WAPE / MASE / bias) is checked if present
+# next to the artifact (e.g. forecast.csv + accuracy.txt / *.md).
+#
+# Usage:
+#   scripts/verify.sh [TARGET_DIR]   (default: current directory)
+#
+# Exit 0 when every found artifact is valid, OR when no artifact exists yet
+# (a clean/empty target is not a failure). Exit 1 only on a malformed artifact.
+
+set -euo pipefail
+
+TARGET="${1:-.}"
+
+if [ ! -d "$TARGET" ]; then
+  echo "verify: target '$TARGET' is not a directory" >&2
+  exit 1
+fi
+
+# Candidate artifacts: CSVs whose name suggests a forecast, plus any CSV whose
+# header literally contains a `forecast` column. Read-only discovery; no writes.
+# Portable to bash 3.2 (no mapfile).
+all_csv="$(find "$TARGET" -type f -name '*.csv' 2>/dev/null || true)"
+
+by_name="$(printf '%s\n' "$all_csv" | grep -Ei 'forecast|prevision|prediccion|prediccio|demand' || true)"
+
+by_header=""
+while IFS= read -r f; do
+  [ -z "$f" ] && continue
+  if head -n 1 "$f" 2>/dev/null | grep -qiE '(^|,)forecast(,|$)'; then
+    by_header="$by_header$f
+"
+  fi
+done <<EOF
+$all_csv
+EOF
+
+# Merge and de-duplicate the two lists.
+artifacts=$(printf '%s\n%s\n' "$by_name" "$by_header" | sed '/^$/d' | sort -u || true)
+
+if [ -z "$artifacts" ]; then
+  echo "verify: no forecast artifact found under '$TARGET' — nothing to check (clean)."
+  exit 0
+fi
+
+fail=0
+checked=0
+
+while IFS= read -r f; do
+  [ -z "$f" ] && continue
+  checked=$((checked + 1))
+  header="$(head -n 1 "$f" 2>/dev/null || true)"
+  total_lines="$(wc -l < "$f" 2>/dev/null | tr -d '[:space:]')"
+  [ -z "$total_lines" ] && total_lines=1
+  rows=$((total_lines - 1))  # minus header
+  lc_header="$(printf '%s' "$header" | tr '[:upper:]' '[:lower:]')"
+
+  problems=()
+
+  # 1. ds + forecast columns
+  printf '%s' "$lc_header" | grep -qE '(^|,)ds(,|$)' || problems+=("missing 'ds' column")
+  printf '%s' "$lc_header" | grep -qE '(^|,)forecast(,|$)' || problems+=("missing 'forecast' column")
+
+  # 2. at least one interval column: lo/hi or statsforecast *-lo-*/*-hi-*
+  if ! printf '%s' "$lc_header" | grep -qE '(^|,)(lo|hi)(,|$)|-lo-|-hi-'; then
+    problems+=("no interval column (expected lo/hi or *-lo-*/*-hi-*)")
+  fi
+
+  # 3. at least one data row
+  if [ "$rows" -lt 1 ]; then
+    problems+=("no data rows (header only)")
+  fi
+
+  if [ "${#problems[@]}" -eq 0 ]; then
+    echo "verify: OK  $f  ($rows row(s))"
+  else
+    fail=1
+    echo "verify: FAIL $f" >&2
+    for p in "${problems[@]}"; do echo "         - $p" >&2; done
+  fi
+done <<< "$artifacts"
+
+# Accuracy readout check (advisory): warn, do not fail, if no WAPE/MASE/bias text
+# accompanies the artifacts. The forecast itself is the hard contract.
+if ! grep -rqiE 'wape|wmape|\bmase\b|\bbias\b' "$TARGET" 2>/dev/null; then
+  echo "verify: note — no accuracy readout (WAPE/MASE/bias) found near artifacts; ship one." >&2
+fi
+
+echo "verify: checked $checked artifact(s)."
+exit "$fail"

package/skills/fundraising/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: fundraising
+description: "Use when planning or running an equity fundraising round and you need the STRATEGY and PROCESS, not a single document — sizing the raise to a milestone, choosing post-money SAFE vs priced round, building and tiering the investor target list around intro paths, sequencing outreach to manufacture momentum, managing the diligence pipeline, or reading a term sheet to know what to push on before you sign. Triggers: 'plan our seed raise', 'how much should we raise and on what terms', 'SAFE or priced round, what cap', 'build my investor target list', 'how many investors do I actually need to contact', 'we have meetings but no term sheet — the raise stalled', 'got a term sheet, what do I push back on', 'planifica la ronda seed', 'cuántos inversores tengo que contactar', '¿SAFE o ronda con precio?', 'planifiquem la ronda d'inversió'. NOT the slide-deck narrative (that is pitch-deck) and NOT the cap-table/valuation math (that is financial-model)."
+tags: [fundraising, seed, safe, term-sheet, investor-pipeline, venture-capital, round-strategy]
+recommends: [pitch-deck, financial-model, investor-materials, cold-outreach, contracts, grants, unit-economics]
+origin: risco
+---
+
+# Fundraising — The Operating System for an Equity Round
+
+*Own the round as a PROCESS: size it, pick the instrument, build a tiered list around intro paths, run a concentrated sprint, read the term sheet. You do NOT write the deck, build the model, or package the data room — you decide the strategy and drive the sequence.*
+
+This skill thinks in **funnels** (how many investors at the top to land N term sheets), in **instruments** (post-money SAFE vs priced Series Seed), and in **leverage** (warm intros, parallel meetings, a first term sheet that creates real urgency). It consumes the deck, the model, and the collateral that siblings produce, and orchestrates them into a closed round. Scope: pre-seed through Series A priced rounds and SAFE rounds, founder-side.
+
+## What this owns vs what routes out
+
+Fundraising owns the **decisions and the sequence**. The moment the real ask is a *document* or the *numbers behind it*, route out — do not half-build the sibling's artifact here.
+
+| The ask is… | Route to | Why |
+| --- | --- | --- |
+| The persuasive STORY / slide narrative | `../pitch-deck/SKILL.md` | The deck is the story; fundraising decides when and to whom it goes. |
+| Revenue projection, burn/runway, valuation math, cap-table dilution | `../financial-model/SKILL.md` | The numbers and the spreadsheet; fundraising sets the *target* (amount, dilution band), the model computes it. |
+| Investor one-pager, data room, recurring investor update | `../investor-materials/SKILL.md` | Packaged collateral; fundraising decides the sequence it ships in. |
+| The actual cold-email/DM copy + follow-up cadence to a named target | `../cold-outreach/SKILL.md` | Fundraising decides WHO and the order; cold-outreach writes the message when there is no warm intro. |
+| Drafting/redlining the binding SAFE, SPA, or side letter | `../contracts/SKILL.md` | The legal instrument; fundraising covers the term-sheet *basics* a founder negotiates, not the binding doc. |
+| Non-dilutive funding (grants, R&D credits, public funding) | `../grants/SKILL.md` | Out of equity-round scope entirely. |
+| The standalone LTV/CAC/payback analysis investors will probe | `../unit-economics/SKILL.md` | A separate diligence artifact; fundraising just knows they'll ask. |
+
+A general sales pipeline for CUSTOMERS (not investors) is `../sales-pipeline/SKILL.md`, not this skill.
+
+## Intake gate — answer these before planning anything
+
+This is a real branch: if the answer to the last row is "the deck" or "the model," STOP and route. Do not produce a round plan on top of unknowns.
+
+- [ ] **Stage & traction** — pre-seed/seed/A? Pre-revenue, or MRR + growth rate (e.g. "$12K MRR, +18% MoM")?
+- [ ] **Milestone the money buys** — what does this round let you prove (e.g. "$100K MRR," "10 design partners → repeatable sales")? If you can't name it, you can't size the round.
+- [ ] **Runway you need to buy** — months to that milestone × monthly burn = the floor of the raise.
+- [ ] **Lead in hand?** — is a lead investor already circling, or is this a cold start? This flips the instrument and the sprint plan.
+- [ ] **Network reality** — strong warm-intro paths, or a weak network? This decides whether you lean on accelerators / portfolio founders.
+- [ ] **Collateral ready?** — deck, model, and data room exist? If the real request is "build the deck" → `../pitch-deck/SKILL.md`. If it's "build the model" → `../financial-model/SKILL.md`. Come back with strategy once they exist.
+
+## Step 1 — Size the round to a milestone
+
+The amount is **burn to the next fundable milestone + buffer**, never "the maximum we can get." Raising too much sells too much of the company for proof you haven't generated yet; raising too little strands you between milestones.
+
+```text
+Amount  = months_to_milestone × monthly_burn × (1 + buffer)   # buffer ~25–35%
+Dilution target:  pre-seed 10–15%   ·   seed 15–25%
+Cap / pre-money ≈ amount ÷ dilution_target
+```
+
+```text
+Bad  — "Let's raise as much as we can — $4M sounds good."
+Good — "$1.5M buys 18 months to $100K MRR at our $80K/mo burn.
+        Aim for ~15% dilution → ~$10M post-money SAFE cap."
+```
+
+2026 reference bands (ground your ask, don't quote them as gospel): median **seed ~$3.1M at ~$16M pre-money**; pre-seed SAFE caps commonly **$10–15M** for $250K–$2M raised. Seed deal *volume* fell ~28% YoY — fewer rounds close but larger, so targeting quality beats spray. Hand the actual cap-table dilution arithmetic to `../financial-model/SKILL.md`; you set the target band, it computes the table.
+
+## Step 2 — Pick the instrument (don't default)
+
+Make the SAFE-vs-priced call explicit. Below ~$4M with no lead, a **post-money SAFE with a valuation cap** is the standard; above that, or with a complex cap table or a lead who wants control terms, expect a **priced equity round** with preferred stock. ~90% of pre-seed rounds on Carta in Q1 2025 used a SAFE; ~92% of all pre-priced rounds as of Q3 2025.
+
+| Signal | Lean SAFE | Lean priced round |
+| --- | --- | --- |
+| Round size | < ~$4M | ≥ ~$4M |
+| Lead investor | none yet / party round | a lead setting terms |
+| Cap table | simple, few holders | complex, many holders / cleanup needed |
+| Legal cost & speed | ~$0–2k, days (YC template) | ~$15–25k, weeks |
+| Governance | founder keeps full control | board seat / protective provisions expected |
+
+Two traps to flag every time:
+
+1. **Post-money SAFE pile-up.** A post-money SAFE fixes the holder's ownership *after all SAFE money but before the priced round*, so **stacking multiple post-money SAFEs dilutes founders more than they expect**. Compute combined dilution across the whole stack *before* signing the next one — hand the real math to `../financial-model/SKILL.md`. Most post-money SAFEs are cap-only (no discount); add a discount only if there's a reason.
+2. **Over-engineering a priced round too early.** A $15–25k priced round before you have traction or a lead burns cash and weeks for governance you don't need yet. Default small/early rounds to SAFE.
+
+SAFE-vs-priced decision table with cost/speed/dilution columns and a worked pile-up example → `references/process-playbook.md`.
+
+## Step 3 — Build the target list, tiered by intro path
+
+The funnel is brutal and quantifiable, so build the list **backward from term sheets**, keyed to *how you'll get in the door* — not a flat list of names.
+
+```text
+Work backward:
+  want ~2–3 term sheets
+  first→second meeting ~50%, outreach→meeting ~15%
+  ⇒ ~50–100+ qualified, warmth-weighted targets at the top of the funnel
+```
+
+The intro path is the single biggest lever: **a warm intro converts to a meeting ~30–50%; cold outreach replies ~1–3% and yields <2% meetings (≈10–20x cold).** So rank every target by the warmest path you have to it:
+
+```text
+Warm-intro priority ladder (best → last resort)
+  1. Existing investors / angels who can route you in
+  2. Portfolio founders of the target VC (they get read)
+  3. Mutual advisors / operators / accelerator network
+  4. Cold outreach — last resort, only where no path exists
+```
+
+Tier A/B/C by **fit × intro warmth** (A = perfect-stage, perfect-thesis, warm path). If your network is weak, manufacture paths: accelerator demo days, portfolio-founder intros, scout programs.
+
+```text
+Bad  — One flat list of 200 VC names, same blast to all.
+Good — 60 targets, each row tagged: stage fit · thesis fit · tier · warmest
+        intro path · who makes the intro. Cold is a labeled minority.
+```
+
+The full back-solve arithmetic, per-path conversion bands, the A/B/C rubric, the pipeline stage schema, and a worked $3M-seed example → `references/funnel-math.md`. When there's genuinely no warm path to a Tier-A target, the message copy itself is `../cold-outreach/SKILL.md`.
+
+## Step 4 — Run it as a concentrated sprint, not a trickle
+
+Momentum is manufactured by **simultaneity**, not by sending one email and waiting. Concentrate **30–50 first meetings in the first ~2 weeks** of launch, run them in parallel, and aim for a first term sheet inside ~2 weeks. Total process targets **~6–8 weeks** — though the tighter 2025 market stretched full cycles to 12–18 months when momentum was absent.
+
+```text
+Sprint shape
+  Pre-launch    line up intros, finalize deck/model/data-room, batch meetings
+  Weeks 1–2     30–50 first meetings IN PARALLEL — this is what creates competition
+  Weeks 3–4     partner meetings, diligence, drive toward the first term sheet
+  Close         first term sheet → use it to compress the rest → sign
+```
+
+**The first term sheet changes everything** — it converts soft interest into urgency across the whole pipeline. Use it. But the honesty rule is absolute:
+
+> **Manufacture FOMO from a visibly busy calendar and a real first term sheet — never from fabricated competing offers or invented deadlines.** Lying about a term sheet you don't have is how a raise dies when one investor calls another; the cost of getting caught is the round.
+
+Track **count-in-pipeline and stage conversion, not activity**. Benchmarks to instrument the funnel: outreach→meeting ~15%, first→second ~50%. Pipeline stages: `Sourced → Intro requested → First meeting → Partner/2nd → Diligence → Term sheet → Closed`. Week-by-week playbook and the honest-momentum mechanics → `references/process-playbook.md`.
+
+## Step 5 — Read the term sheet (the basics, then hand off)
+
+A founder negotiates the few terms that **compound** — not the headline valuation alone. Know the 2025 market-standard bands so you know what to accept and what to push on.
+
+| Term | Q2 2025 market standard at seed | Push on it when… |
+| --- | --- | --- |
+| Liquidation preference | ~98% 1x; ~95% non-participating (founder-friendly) | Anything above **1x** or **participating** — push hard; it's off-market. |
+| Valuation cap / pre-money | derives your dilution | The cap implies dilution outside your band (Step 1). |
+| ESOP / option pool | carved pre-money dilutes founders | A large pool demanded "for hiring" inflates dilution silently. |
+| Board composition | common post-seed: 2 founder / 1 investor | Anything that loses you founder majority at seed. |
+| Pro-rata rights | common | Fine to grant; know who's reserving follow-on. |
+| Protective provisions / vetoes | appeared in >90% of rounds | Scope creep beyond standard major-decision vetoes. |
+
+Median seed lead ownership runs ~12.6%. **Don't sign the first term sheet without a comparison** — a single offer with no comp gives away your only leverage. And the hard handoff: the term sheet is mostly non-binding, but **the binding SAFE / SPA / side letter is a legal document → `../contracts/SKILL.md` and a real lawyer.** You read the term sheet to negotiate; you do not draft the binding instrument here. Full term-by-term cheat sheet with bands and push-on guidance → `references/process-playbook.md`.
+
+## Anti-patterns / rationalizations → STOP
+
+| Rationalization | Reality / Fix |
+| --- | --- |
+| "Raise the max — more runway is always better." | More dilution for proof you don't have. Size to the next milestone (Step 1). |
+| "I'll send a few emails and see who bites." | A serial trickle kills momentum. Concentrate 30–50 meetings in 2 weeks, parallel. |
+| "Bigger list = better — blast 200 VCs." | Flat spray wastes your warm paths. Tier by fit × intro warmth; cold is a labeled minority. |
+| "Let's do a priced round to look serious." | $15–25k and weeks for governance you don't need pre-traction/pre-lead. Default to SAFE. |
+| "First term sheet looks fine, let's sign." | One offer with no comp = zero leverage. Get a comparison before you sign. |
+| "Stack another post-money SAFE, easy money." | Pile-up dilutes you more than you think. Model the whole stack first (`../financial-model/SKILL.md`). |
+| "Cold outreach is the main channel." | Cold replies ~1–3%; warm converts ~30–50%. Build around intro paths, cold last. |
+| "Tell investors we have a competing term sheet." | If untrue, the raise dies when they call each other. FOMO from real signals only. |
+| "Push the valuation up, that's the win." | The terms that compound are pref, pool, board, dilution — not headline price alone. |
+
+## Handoffs + references
+
+- Story / slides → `../pitch-deck/SKILL.md` · numbers, cap-table, valuation → `../financial-model/SKILL.md` · one-pager, data room, updates → `../investor-materials/SKILL.md`.
+- Cold message copy → `../cold-outreach/SKILL.md` · binding legal doc → `../contracts/SKILL.md` · non-dilutive → `../grants/SKILL.md` · LTV/CAC probe → `../unit-economics/SKILL.md`.
+- `references/funnel-math.md` — work-backward funnel arithmetic, warm-intro priority ladder with per-path conversion bands, A/B/C tiering rubric, pipeline stage schema, worked $3M-seed top-of-funnel.
+- `references/process-playbook.md` — 6–8 week sprint week-by-week, honest momentum/FOMO mechanics, SAFE-vs-priced decision table (cost/speed/dilution), post-money SAFE pile-up worked example, term-sheet-basics cheat sheet with 2025 bands.

package/skills/fundraising/evals/README.md

@@ -0,0 +1,18 @@
+# Eval harness — `fundraising` skill
+
+These cases are read by the skill-eval harness (an agent harness with the full
+skill catalog loaded for routing, e.g. `agent-eval`), not a shell runner —
+triggering precision and round-strategy quality are judgment calls. `cases.yaml`
+holds three blocks. `should_trigger` / `should_not_trigger` check **routing**:
+the skill must fire on round-strategy/process asks and stay quiet on near-misses
+that belong to a sibling (the recurring traps are the deck → `pitch-deck`, the
+numbers → `financial-model`, the collateral → `investor-materials`, the message
+copy → `cold-outreach`, and the binding legal doc → `contracts`). `capability`
+checks the **reasoning**: for the pre-seed scenario, run the agent with and
+without the skill and grade the output against the `must_include` rubric —
+the win condition is sizing to a milestone, the correct SAFE call with the
+pile-up flag, a back-solved warm-weighted funnel, a parallel sprint, clean
+handoffs to the siblings, and zero dishonest-FOMO coaching. No live API or
+network is needed — cases are static prompts plus rubrics; run several trials
+per prompt (context is stochastic), report the raw fraction, and re-grade after
+any edit to `SKILL.md` or its `references/`.

package/skills/fundraising/evals/cases.yaml

@@ -0,0 +1,76 @@
+skill: fundraising
+
+# Prompts that MUST load `fundraising`. The skill owns the equity round as a
+# PROCESS: sizing the raise to a milestone, the SAFE-vs-priced instrument call,
+# building/tiering the investor list around intro paths, sequencing outreach for
+# momentum, the pipeline, and reading the term-sheet basics. It does NOT write
+# the deck (pitch-deck), build the model (financial-model), package collateral
+# (investor-materials), draft the binding legal doc (contracts), or write the
+# cold-email copy (cold-outreach).
+should_trigger:
+  - prompt: "Help me plan our seed raise — how much should we raise and on what terms?"
+    why: "Core round-planning ask: size the round to a milestone, set the dilution band, derive the cap — the skill's Step 1 plus instrument call."
+
+  - prompt: "SAFE or priced round for our $1.5M pre-seed? What cap should we set?"
+    why: "The instrument decision (size, lead, cap-table complexity, cost/speed) and cap derivation are Step 2, the skill's core."
+
+  - prompt: "Build my investor target list and tell me how many I need to contact to close."
+    why: "Tiered target list + back-solving the top-of-funnel from conversion math is Step 3 / references/funnel-math.md."
+
+  - prompt: "We've had 20 investor meetings and zero term sheets — what's wrong with our process?"
+    why: "NON-OBVIOUS: a process diagnosis, not a document. The funnel/stage-conversion read (serial vs parallel, momentum) is squarely fundraising."
+
+  - prompt: "Cuántos inversores tengo que contactar para cerrar la ronda y cómo secuencio el outreach?"
+    why: "Spanish: funnel sizing + outreach sequencing for momentum — Step 3 and Step 4."
+
+  - prompt: "We got a term sheet with a 2x participating liquidation preference — should I push back?"
+    why: "NON-OBVIOUS routing: this is the founder's NEGOTIATION read of market-standard terms (Step 5), not the legal redline of the binding doc."
+
+  - prompt: "Planifiquem la ronda d'inversió: quant aixequem, amb quin instrument i com muntem el pipeline d'inversors?"
+    why: "Catalan: round sizing + instrument + investor pipeline — the full process the skill owns end to end."
+
+  - prompt: "How do I sequence outreach so I create real momentum and FOMO without lying about offers we don't have?"
+    why: "Sprint sequencing and the honest-momentum mechanics are Step 4; the honesty rule is a core part of the skill."
+
+should_not_trigger:
+  - prompt: "Write our seed pitch deck narrative and fix the traction slide."
+    route_to: "pitch-deck"
+    why: "The persuasive slide story is pitch-deck; fundraising decides when/to whom the deck goes, not what the slides say."
+
+  - prompt: "Build the revenue projection and the cap-table dilution model behind the raise."
+    route_to: "financial-model"
+    why: "The numbers and the spreadsheet are financial-model; fundraising sets the target band, the model computes the table."
+
+  - prompt: "Draft our investor one-pager and set up the data room."
+    route_to: "investor-materials"
+    why: "Packaged collateral is investor-materials; fundraising only decides the sequence it ships in."
+
+  - prompt: "Write the actual cold email to this specific VC since I have no warm intro."
+    route_to: "cold-outreach"
+    why: "The message copy and follow-up cadence to a named target is cold-outreach; fundraising decides WHO and the order, not the words."
+
+  - prompt: "Redline the SAFE document our lawyer sent — is this language actually binding on us?"
+    route_to: "contracts"
+    why: "Drafting/redlining the binding legal instrument is contracts; fundraising covers the non-binding term-sheet basics a founder negotiates."
+
+  - prompt: "We want non-dilutive funding — help us with the R&D grant application."
+    route_to: "grants"
+    why: "Non-dilutive funding is out of equity-round scope entirely and owned by grants."
+
+  - prompt: "Set up our sales pipeline stages to convert inbound customers into paying accounts."
+    route_to: "sales-pipeline"
+    why: "A pipeline for CUSTOMERS, not investors; despite the 'pipeline' overlap this is sales-pipeline."
+
+capability:
+  - scenario: >
+      Pre-seed SaaS, $12K MRR growing 18% MoM, 6 months runway, no lead investor,
+      and the founder has a weak network. They ask: how much should we raise, SAFE
+      or priced, how big a target list, and how do we run the process?
+    must_include:
+      - "Sizes the round to a fundable milestone (burn × months to milestone + buffer), NOT 'as much as possible', with a pre-seed dilution band (~10–15%) and a cap rationale derived from amount ÷ dilution."
+      - "Recommends a post-money SAFE over a priced round for this small, no-lead case (cost ~$0–2k vs $15–25k, speed, simple cap table), and explicitly flags the post-money SAFE pile-up dilution trap."
+      - "Builds the target list from the warm-intro ladder and back-solves the top-of-funnel from ~15% outreach→meeting / ~50% first→second to land ≥2 term sheets — i.e. ~50–100+ warmth-weighted targets, not a flat spray."
+      - "Directly addresses the weak-network constraint by manufacturing intro paths (accelerator, portfolio-founder intros, scouts, syndicates) rather than defaulting to cold."
+      - "Lays out a concentrated sprint: 30–50 first meetings in ~2 weeks, parallel not serial, first term sheet as the unlock, ~6–8 week target — and says don't sign the first term sheet without a comparison."
+      - "Routes the deck to pitch-deck, the model/cap-table to financial-model, the one-pager/data-room to investor-materials, the cold message copy to cold-outreach, and the binding doc to contracts/a lawyer."
+      - "Does NOT fabricate competing offers, invent deadlines, or coach any dishonest FOMO — momentum comes from real signals only."

package/skills/fundraising/references/funnel-math.md

@@ -0,0 +1,90 @@
+# Funnel math, intro paths, tiering & the pipeline schema
+
+Everything here serves one job: build a target list **sized from the term sheets you need**, weighted toward warm paths, and tracked by stage conversion instead of activity. The arithmetic is deliberately conservative — round down, then add buffer.
+
+## Work backward from term sheets
+
+You don't pick a list size and hope. You start from the outcome and divide.
+
+```text
+Target outcomes        ~2–3 term sheets (you want a comparison, not a single offer)
+First→second meeting   ~50%   (a strong first meeting half-converts to a partner/2nd)
+Outreach→first meeting ~15%   (blended across warm + cold; cold drags this down hard)
+
+Back-solve (illustrative, blended warmth):
+  3 term sheets
+   ÷ ~10–15% (meeting → term sheet, after diligence attrition)
+   ⇒ ~20–30 real first meetings
+   ÷ ~15% (outreach → first meeting)
+   ⇒ ~130–200 outreaches at pure-blended rates
+```
+
+That blended number is why **warmth is the whole game**: shift the mix toward warm intros and the required top-of-funnel collapses. A list that is 60% warm needs far fewer names than a 100%-cold list for the same meeting count. Practical target for a seed: **~50–100+ qualified targets**, warmth-weighted, not 200 cold names.
+
+## Warm-intro priority ladder (with conversion bands)
+
+Rank every target by the **warmest path you actually have**, not by how much you like the fund.
+
+```text
+Path                                          Outreach → meeting
+1. Existing investor / angel routes you in    ~30–50%   (best; they vouch)
+2. Portfolio founder of the target VC         ~30–50%   (founders get read fast)
+3. Mutual advisor / operator / accelerator    ~20–35%   (warm-ish)
+4. Cold email / DM (no path)                  ~1–3%     (last resort)
+```
+
+The spread between row 1 and row 4 is ~10–20x. So the list-building work is **finding the path**, not collecting names: for every Tier-A fund, ask "who is the warmest human who can introduce me?" before the fund goes on the list.
+
+**Weak-network playbook:** if you have few warm paths, manufacture them — accelerator demo days, scout programs, portfolio-founder intros (cold-email a portfolio founder, not the partner — founders answer founders), angel syndicates, and operator communities. Build the warm layer first; only then let `../cold-outreach/SKILL.md` write the cold messages for the genuine no-path targets.
+
+## A/B/C tiering rubric (fit × intro warmth)
+
+Score each target on two axes, then bucket. Spend your concentrated sprint on A and B.
+
+| Tier | Stage fit | Thesis/sector fit | Intro warmth | Treatment |
+| --- | --- | --- | --- | --- |
+| **A** | exact stage (writes your check size) | core thesis (sector + model) | warm path (ladder 1–2) | first wave, week 1, partner-targeted |
+| **B** | adjacent stage or check | adjacent thesis | warm-ish (ladder 3) | second wave, week 1–2 |
+| **C** | possible | weak/unknown fit | cold (ladder 4) | only if A/B underfill the funnel |
+
+Tag every row with: **stage fit · thesis fit · tier · warmest intro path · who makes the intro · status**. A target with perfect thesis fit but no path is still a B/C until you find the path — fit without access is not a real lead.
+
+## Pipeline stage schema
+
+Track **count-in-stage and stage-to-stage conversion**, not "emails sent." If a stage isn't converting at its benchmark, that's your diagnosis (see below).
+
+```text
+Sourced            → on the list, tier assigned, path identified
+Intro requested    → asked the connector / sent the (warm or cold) outreach
+First meeting      → met (call/in-person)
+Partner / 2nd      → advanced to a second/partner meeting
+Diligence          → data-room access, references, deep dive
+Term sheet         → received an offer
+Closed             → signed & wired
+```
+
+Conversion benchmarks to instrument it: **outreach → meeting ~15%**, **first → second ~50%**. Watch where you fall off market:
+
+- High outreach, low **first-meeting** rate → list is too cold or off-thesis. Fix warmth/fit, not volume.
+- Good first meetings, low **second-meeting** rate → the story/traction isn't landing (`../pitch-deck/SKILL.md`) or the numbers don't hold (`../financial-model/SKILL.md`).
+- Meetings but **no term sheet** → momentum is serial, not parallel; you're not running a sprint (see `process-playbook.md`).
+
+## Worked example — sizing the top-of-funnel for a $3M seed
+
+```text
+Goal:           $3M seed, want 2–3 term sheets to create a comparison
+Network:        moderate — some warm paths, accelerator alum
+
+Target meetings:   ~25 strong first meetings (to yield 2–3 term sheets after attrition)
+Warmth mix:        aim 60% warm / 40% cold
+
+Warm slice (15 meetings @ ~35% warm conversion):   ~43 warm outreaches
+Cold slice  (10 meetings @ ~2%  cold conversion):  ~500 cold outreaches  ← brutal
+
+Decision: that cold slice is uneconomical. Re-weight to 80% warm:
+  20 warm meetings @ ~35% ⇒ ~57 warm outreaches
+   5 cold meetings @ ~2%  ⇒ ~250 cold outreaches
+Top-of-funnel:  ~60 Tier-A/B warm targets + a small cold tail.
+```
+
+The lesson the math forces: **the cold tail is a rounding error of meetings for a mountain of work** — invest the time in manufacturing warm paths, not in scaling cold. Hand the resulting dilution and cap-table arithmetic to `../financial-model/SKILL.md`; hand the cold-message copy for the tail to `../cold-outreach/SKILL.md`.

package/skills/fundraising/references/process-playbook.md

@@ -0,0 +1,97 @@
+# The sprint playbook, the instrument decision, and the term-sheet cheat sheet
+
+The SKILL.md gives the rules; this gives the week-by-week sequence, the SAFE-vs-priced detail, and the term-by-term read. Defer all real cap-table math to `../financial-model/SKILL.md`.
+
+## The 6–8 week sprint, week by week
+
+A raise is won by **simultaneity**. The default target is ~6–8 weeks; the 2025 market stretched cold-start cycles to 12–18 months when momentum was absent, so the whole point of the sprint is to never give the market time to cool.
+
+```text
+Pre-launch (1–2 weeks before)
+  · Finalize deck (pitch-deck), model (financial-model), data room (investor-materials)
+  · Build the tiered list and confirm intro paths (funnel-math.md)
+  · Pre-warm connectors: line up the intros so they fire in a batch on day 1
+  · DO NOT take real meetings yet — a leaked early "no" with no momentum hurts
+
+Weeks 1–2  ·  The meeting burst
+  · 30–50 first meetings IN PARALLEL — this density is what creates competition
+  · Same week for all of Tier A; investors talk, and a busy calendar signals a hot deal
+  · Tight, repeatable first-meeting narrative; capture every follow-up ask same day
+
+Weeks 3–4  ·  Partner meetings & diligence
+  · Convert first meetings → partner/2nd meetings (~50% target)
+  · Feed diligence fast (data room ready = days saved); slow responses read as disorganized
+  · Drive explicitly toward the FIRST term sheet — it is the unlock
+
+Close
+  · First term sheet in hand → use it to compress everyone else's timeline
+  · Run a short, honest "we're moving to decisions this week" to the live pipeline
+  · Compare offers (never sign the only one), negotiate the compounding terms, sign
+```
+
+## Honest momentum / FOMO mechanics
+
+FOMO is real and worth manufacturing — but only from true signals. The asymmetry: a fabricated competing offer wins you nothing investors can't unravel, and unravels the whole round when two partners compare notes.
+
+```text
+Legitimate momentum levers          Forbidden (round-killers)
+· A visibly busy meeting calendar    · "We have a term sheet" when you don't
+· A real first term sheet            · Invented deadlines / fake closing dates
+· Parallel timelines ("decisions     · Naming a competing fund that isn't in
+   this week"), stated honestly         · Inflating the round size or interest
+· Letting investors infer demand     · Any claim you couldn't defend if called
+   from the cadence, not from claims
+```
+
+The rule: every signal you project must survive an investor calling another investor. If it wouldn't, don't say it.
+
+## SAFE vs priced — the full decision table
+
+| Dimension | Post-money SAFE | Priced equity round |
+| --- | --- | --- |
+| Typical size | < ~$4M | ≥ ~$4M |
+| Lead required | no (works as a party round) | usually yes (lead sets terms) |
+| Legal cost | ~$0–$2,000 (YC template) | ~$15,000–$25,000 attorney fees |
+| Speed | days | weeks |
+| Instrument | converts later, no stock issued now | preferred stock issued now |
+| Governance | founder keeps full control | board seat / protective provisions likely |
+| Cap-table impact | deferred to conversion (watch the pile-up) | priced & on the cap table immediately |
+| Best when | small/early, no lead, simple cap table, need speed | larger, lead present, complex cap table, governance expected |
+
+Market reality: ~90% of pre-seed rounds on Carta in Q1 2025 used a SAFE; ~92% of all pre-priced rounds as of Q3 2025. Below ~$4M, SAFE is the default; above it (or with a lead wanting control), price it.
+
+## Post-money SAFE pile-up — worked example
+
+A post-money SAFE fixes the holder's ownership **after all SAFE money but before the priced round**. Founders read each SAFE in isolation and are shocked at conversion when several stack. Model the whole stack *before* signing the next one.
+
+```text
+Illustrative pile-up (directional — run the real math in financial-model):
+  SAFE 1:  $500K  @ $5M post-money cap   →  holder fixed at ~10% post-conversion
+  SAFE 2:  $500K  @ $7M post-money cap   →  holder fixed at ~7.1%
+  SAFE 3:  $500K  @ $8M post-money cap   →  holder fixed at ~6.25%
+
+  Founders read each as "small." Combined, the SAFE holders are pre-committed to
+  ~23%+ of the post-priced cap table BEFORE the new-money priced round and the
+  option-pool top-up dilute founders further. The stack compounds; the pieces hide it.
+```
+
+Most post-money SAFEs are **cap-only (no discount)** — add a discount only with a specific reason (e.g. very early, no cap agreeable). The instant a SAFE stack gets non-trivial, push the exact combined-dilution table to `../financial-model/SKILL.md`.
+
+## Term-sheet basics cheat sheet (2025 bands + what to push on)
+
+Negotiate the terms that **compound**, not the headline valuation alone. Bands are Q2 2025 market standard at seed.
+
+| Term | Standard band | Read / what to push on |
+| --- | --- | --- |
+| **Liquidation preference** | ~98% **1x**; ~95% **non-participating** | 1x non-participating is founder-friendly and market. Anything **>1x** or **participating** is off-market — push hard or walk. |
+| **Valuation cap / pre-money** | sets your dilution | Translate cap → implied dilution; reject anything outside your Step-1 band. Median seed lead ownership ~12.6%. |
+| **ESOP / option pool** | carved **pre-money** | The hidden dilution lever. A big "for hiring" pool inflates the lead's effective ownership at your expense. Size it to the real 12–18mo hiring plan. |
+| **Board composition** | common post-seed **2 founder / 1 investor** | Keep founder majority at seed. A 2/1 investor-majority board at seed is a red flag. |
+| **Pro-rata rights** | common | Generally fine to grant; know who reserves follow-on so the next round isn't a surprise. |
+| **Protective provisions / vetoes** | in **>90%** of rounds | Standard major-decision vetoes are normal. Push back on scope creep into ordinary operating decisions. |
+| **Anti-dilution** | broad-based weighted-average is standard | Reject full-ratchet — it's punitive and off-market at seed. |
+
+Two hard rules:
+
+1. **Never sign the first term sheet without a comparison.** A single offer with no comp gives away all your leverage. The first term sheet's real value is the urgency it creates across the rest of the pipeline.
+2. **The term sheet is mostly non-binding; the SAFE / SPA / side letter is binding.** You read and negotiate the term sheet here. The binding instrument goes to `../contracts/SKILL.md` and a real startup lawyer — do not draft or redline the binding doc from this skill.