@damiangilgonzalez/harness 1.3.7

package/skills/sales-pipeline/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: sales-pipeline
+description: "Use when an operator runs deals out of a spreadsheet or Notion and wants real stages, win probabilities, deal hygiene, a weekly follow-up sweep, and a defensible roll-up forecast — including the case where the pipeline looks full but nothing closes. NOT statistical or scenario forecast modelling (that is `forecasting`), NOT sourcing prospects (that is `lead-gen`), NOT writing the outbound emails (that is `cold-outreach`), NOT the proposal or quote (that is `proposals`), NOT the post-close kickoff (that is `client-onboarding`)."
+tags: [sales, crm, pipeline, forecasting, deal-hygiene, business-ops]
+recommends: [forecasting, lead-gen, cold-outreach, proposals, client-onboarding, spreadsheet-ops]
+origin: risco
+---
+
+# Sales Pipeline — A Disciplined CRM Out of a Flat File
+
+*You run a small team's pipeline from a CSV, a markdown table, or a Notion DB — no Salesforce, no RevOps. Your one rule: the forecast is what the gated stages and current win rates say, not what the rep hopes. Happy-ears deals do not inflate the number on your watch.*
+
+This skill does four jobs and refuses to drift into the siblings that own the rest: (1) define a **small set of gated stages** with objective exit criteria, (2) keep every open deal **hygienic** (next step + close date + last-touch, flag the stale), (3) run a **weekly follow-up sweep**, and (4) roll a **defensible weighted forecast** with a coverage ratio. The heavy statistical modeling, the lead sourcing, the outbound copy, the proposal, the post-close handoff — each belongs to a sibling. Route, do not improvise their job.
+
+## When to use / when NOT
+
+Use when the operator already has a list of deals and wants stages, probabilities, hygiene, a weekly sweep, coverage vs quota, or pipeline velocity — or when they describe the symptom "pipeline looks full but nothing closes."
+
+Do NOT use when the ask is one of these — route to the owner:
+
+| The ask | Owner | Why it is not here |
+|---|---|---|
+| 3-scenario revenue model, seasonality, cohort/time-series projection | `forecasting` | That is the statistical/scenario layer. This skill only does the simple stage-weighted roll-up that falls out of the pipeline. |
+| Find / scrape / qualify NEW prospect companies to add | `lead-gen` | This skill operates on deals that already exist in the list. |
+| Write the cold email or follow-up sequence to contact a prospect | `cold-outreach` | This skill schedules the next step; it does not write the words. |
+| Write the proposal / quote / SOW for a qualified deal | `proposals` | A stage transition is not a document. |
+| Post-close kickoff, account setup, onboarding | `client-onboarding` | The moment a deal is Closed-Won it leaves this skill. |
+| Generic dashboard / charting of arbitrary metrics, KPI tree design | `dashboard` / `kpi-framework` | This skill emits pipeline numbers, not a charting layer. |
+
+The boundary worth memorizing: **`forecasting` owns the math models; sales-pipeline owns the operational CRM.** When the request needs Monte Carlo, regression, or scenario trees, hand it over.
+
+## The artifact first — the deal-record schema
+
+Everything below lints against one table. Define it before anything else, because hygiene, the sweep, and the forecast are all just operations on these columns. One deal = one row. Required columns:
+
+| column | meaning | rule |
+|---|---|---|
+| `id` | stable deal id | unique, never reused |
+| `company` | the account | — |
+| `value` | deal value (one currency, document which) | number, no symbols |
+| `stage` | current stage | from the allowed set (next section) |
+| `win_prob` | stage win-probability as a decimal | 0–1, **owned by the stage, not the rep** |
+| `weighted_value` | `value × win_prob` | must equal the product (lint enforces it) |
+| `close_date` | expected close (ISO `YYYY-MM-DD`) | required on every open deal |
+| `next_step` | the next concrete action + its date | required on every open deal |
+| `last_touch` | date of last real activity (ISO) | required on every open deal |
+| `owner` | who owns the deal | — |
+| `forecast_category` | Pipeline / Best Case / Commit / Closed / Omitted | a category, **not** a stage |
+
+One good open row (CSV):
+
+```csv
+id,company,value,stage,win_prob,weighted_value,close_date,next_step,last_touch,owner,forecast_category
+D-104,Acme,40000,Discovery,0.30,12000,2026-07-15,"2026-06-09 demo with VP Eng",2026-05-30,Dana,Best Case
+```
+
+Hard rule, no exceptions: **no open deal may be missing `next_step`, `close_date`, or `last_touch`.** A deal with no next step is not a deal, it is a wish. The sweep and the forecast both treat a missing field as a defect, not a blank.
+
+## The stage model — small, gated, stage-owned probability
+
+Default to **six stages**. Five stages with clear exit criteria beat nine stages with none. Each stage advances only on an objective, verifiable **buyer action** — never on rep optimism.
+
+| stage | default `win_prob` | exit criterion (the verifiable buyer action that advances it) |
+|---|---|---|
+| Prospecting | 0.05 | Buyer agreed to a first real conversation (meeting on the calendar). |
+| Qualification | 0.10 | BANT/MEDDIC documented "yes" — budget, authority, need, timeline confirmed. |
+| Discovery | 0.30 | Buyer confirmed the problem + success criteria; you have the buying process and review layers. |
+| Proposal/Demo | 0.40 | Proposal or demo delivered and acknowledged; buyer engaged on it. |
+| Negotiation | 0.65 | Terms/price under active discussion; verbal intent + a mutual close plan. |
+| Closed | 1.0 / 0.0 | Signed (Won) or formally lost (Lost). |
+
+Rules that make the table hold:
+
+- **Probability belongs to the stage, not the deal.** A rep who hand-sets one deal to 90% in Discovery is sandbagging or happy-ears; both poison the forecast. The stage carries the number, uniformly. *(Why: it removes the single biggest source of forecast inflation in small teams.)*
+- **No stage advances without its exit criterion met AND a calendared next step.** "If you don't know the criteria, timeline, review layers and legal steps, the close date is a guess."
+- **Negotiation 50–80% is a band, not a default 80.** Pick within the band on real signal (legal in motion → higher); never max it out reflexively.
+
+Qualification gate: run **BANT as a ~60-second screen** for small deals; switch to **MEDDIC/SPICED above ~$25K ACV**. The full six-stage playbook — every exit criterion, required fields per stage, the BANT-vs-MEDDIC pillars, and the forecast-category mapping — lives in `references/stage-playbook.md`.
+
+## Deal hygiene — the required-field gate and the stale rules
+
+Roughly **40–60% of B2B CRM pipeline is stale** (no progression in 30+ days). A forecast built on a stale list is fiction. Apply an activity-decay model on every open deal:
+
+| condition | action |
+|---|---|
+| Missing `next_step` / `close_date` / `last_touch` | **Defect** — flag, do not forecast until fixed. |
+| No touch for **14+ days** | **Halve** the deal's effective weight in the forecast. |
+| No touch for **30+ days** | **Exclude** from coverage entirely (treat as stale, not pipeline). |
+| Sitting **> 1.5× the average time-in-stage** | Flag for review — it is stuck. |
+| `close_date` already in the past, deal still open | Flag — the date is a lie; re-set or disqualify. |
+
+Bad → Good on a single row:
+
+```text
+BAD  (open, but a wish dressed as a deal — fails the gate):
+  D-220,Globex,60000,Proposal,0.80,48000,,,,Sam,Commit
+  ^ win_prob hand-set to 0.80 in Proposal, no close_date, no next_step,
+    no last_touch, Commit category on zero evidence.
+
+GOOD (gated, hygienic, stage-owned probability):
+  D-220,Globex,60000,Proposal,0.40,24000,2026-08-01,"2026-06-12 send revised SOW",2026-06-02,Sam,Best Case
+  ^ win_prob = stage default, weighted_value recomputed, dated next step,
+    fresh last_touch, category demoted to match the evidence.
+```
+
+## The weekly follow-up sweep
+
+Build hygiene into a **~45-minute WEEKLY pipeline review**, not a quarterly cleanup — stale deals compound fast and a quarterly purge always finds the rot too late. The sweep is a fixed checklist; run it and emit a prioritized follow-up list:
+
+- [ ] Every open deal has `next_step` + `close_date` + `last_touch` — list the defects first.
+- [ ] Stale: no touch 14+ days (halve) and 30+ days (drop) — surface both buckets.
+- [ ] `close_date` in the past on an open deal — re-set or disqualify.
+- [ ] Slipped: `close_date` pushed two weeks in a row — flag; two slips is a pattern, not noise.
+- [ ] Stuck: time-in-stage > 1.5× the average for that stage.
+- [ ] Output: a ranked follow-up list (highest `weighted_value` × most stale first), each with the one concrete next action and its date.
+
+Track coverage as a **4-week rolling trend**, not a single snapshot. **Two consecutive weeks of declining coverage with no closes is a red flag** — escalate, do not wait for quarter-end.
+
+## The forecast roll-up
+
+Three numbers fall out of a clean pipeline. Compute them; do not model beyond them (that is `forecasting`).
+
+**Weighted forecast** = Σ over open deals of `value × stage win_prob`. Apply the stale decay first (halve at 14d, drop at 30d) so the number reflects live pipeline, not the wish list.
+
+**Pipeline coverage ratio** = Total Qualified Pipeline Value ÷ Revenue Target. Read it against the segment, because win rates differ:
+
+| segment | ACV / win rate | coverage min | coverage target |
+|---|---|---|---|
+| Enterprise | $100K+ / 15–20% win | 5× | 6–7× |
+| Commercial | $25–100K / 20–30% | 3.5× | 4–5× |
+| SMB | <$25K / 30–40% | 2.5× | 3–4× |
+
+**Pipeline velocity** = `(Open opps × Avg deal size × Win rate) ÷ Sales-cycle length (days)` → dollars/day. Cycle length has the most leverage: a ~20% cut in cycle length lifts velocity ~25%.
+
+Forecast categories are **not** stages — map them separately: Pipeline / Best Case / Commit / Closed / Omitted. As a sanity expectation, roughly **~25% of "Pipeline", a third-to-half of "Best Case", and near-all of "Commit"** typically lands in-quarter.
+
+**The current-win-rate caveat — non-negotiable.** 2025 benchmarks moved against sellers: B2B win rates fell ~21% → ~18% and cycles lengthened ~12% YoY. **Forecast with the current ~18% win rate and your real cycle length, never last year's optimistic numbers.** A 24-month-old win rate is the quietest way to over-forecast.
+
+Worked examples — weighted forecast on a 5-deal list, coverage by segment, velocity, and the exact column contract `verify.sh` enforces — are in `references/forecasting-math.md`.
+
+## Anti-patterns
+
+| Anti-pattern | Why it fails | Do instead |
+|---|---|---|
+| Rep hand-sets `win_prob` per deal | Happy-ears/sandbagging inflate the forecast; the number stops being comparable | Probability is owned by the stage, applied uniformly |
+| Stages with no exit criteria | "Discovery" becomes a place deals go to die; no one can verify progression | Every stage gates on an objective buyer action |
+| Counting stale deals (30+ days no touch) in coverage | 40–60% of pipeline is stale; coverage looks healthy while nothing moves | Drop 30d+ from coverage, halve 14d+, flag stuck deals |
+| Forecasting off list price, not weighted value | Treats a Qualification deal like a signed one; massive over-forecast | `value × stage win_prob`, decayed for staleness |
+| Quarterly cleanup instead of weekly | Rot is found three months too late; the quarter is already lost | 45-min weekly sweep; 4-week rolling coverage trend |
+| Using a 24-month-old win rate | 2025 win rates fell to ~18%, cycles +12%; old numbers over-forecast | Use the current win rate and your real cycle length |
+| `forecast_category` set to "Commit" on a Discovery deal | Category drifts from evidence; the commit number becomes a fantasy | Category must match documented evidence, not hope |
+| Nine micro-stages "for granularity" | More stages, less discipline; reps can't tell them apart | Six gated stages beat nine ungated ones |
+| Open deal with no `next_step` | It is a wish, not a deal; it silently ages into staleness | No next step → it is a defect, surface it in the sweep |
+
+## References and siblings
+
+- `references/stage-playbook.md` — the six stages in full, exit criteria, required fields per stage, BANT-vs-MEDDIC, forecast-category mapping.
+- `references/forecasting-math.md` — worked weighted-forecast / coverage / velocity examples and the verify column contract.
+
+Siblings that own the adjacent jobs — route to them by name: `../forecasting/SKILL.md` (the math models), `../lead-gen/SKILL.md` (sourcing), `../cold-outreach/SKILL.md` (the outbound copy), `../proposals/SKILL.md` (the quote/SOW), `../client-onboarding/SKILL.md` (post-close). For wiring the list to Sheets/Notion or bulk edits, `../spreadsheet-ops/SKILL.md`.
+
+To lint a pipeline file you produced — required columns, required fields on open deals, stage names in the allowed set, `win_prob` in range, `weighted_value == value × win_prob`, and a coverage line present — run `scripts/verify.sh path/to/pipeline.csv` (read-only; a clean or empty file exits 0).

package/skills/sales-pipeline/evals/README.md

@@ -0,0 +1,13 @@
+# Evals — sales-pipeline
+
+`cases.yaml` is run by the rsc eval harness. The `should_trigger` and
+`should_not_trigger` prompts test the description router: each should-trigger
+prompt must load this skill, and each should-not-trigger prompt must route to
+the named real sibling (`forecasting`, `lead-gen`, `cold-outreach`,
+`proposals`, `client-onboarding`) instead. The single `capability` case is
+graded by a judge against its `must_include` rubric — feed the scenario's 6-row
+deal CSV to the skill and check the output hits every rubric line (required-field
+gate, stage-owned probabilities, 14d/30d stale decay, weighted forecast,
+coverage-vs-quota verdict at the current ~18% win rate, and a lint-able artifact).
+No external API or network access is required; everything is local to the model
+and the harness.

package/skills/sales-pipeline/evals/cases.yaml

@@ -0,0 +1,60 @@
+skill: sales-pipeline
+
+# Prompts that MUST load `sales-pipeline`. The skill runs a lightweight CRM out
+# of a flat file: gated stages, deal hygiene, a weekly follow-up sweep, and a
+# stage-weighted roll-up forecast with a coverage ratio. It does NOT do
+# statistical/scenario modeling (forecasting), source prospects (lead-gen),
+# write outbound copy (cold-outreach), write the proposal (proposals), or run
+# post-close onboarding (client-onboarding).
+should_trigger:
+  - prompt: "Set up stages and a weighted forecast for my deal spreadsheet."
+    why: "Core job — define gated stages with exit criteria and roll a stage-weighted forecast off an existing deal list."
+
+  - prompt: "Which of my deals are stale and what should I follow up on this week?"
+    why: "Deal hygiene + the weekly sweep — the 14d/30d activity-decay rules and the prioritized follow-up list answer this directly."
+
+  - prompt: "My forecast keeps slipping every quarter — the pipeline looks full but nothing closes."
+    why: "Non-obvious: the user names a symptom, not the skill. The diagnosis is stale-deal inflation + counting unweighted/uncommitted pipeline in coverage, which is exactly this skill's hygiene + coverage work."
+
+  - prompt: "Munta'm un CRM lleuger amb etapes i previsió de vendes sense pagar Salesforce."
+    why: "Catalan phrasing for a lightweight CRM with stages and a sales forecast — same skill regardless of language."
+
+  - prompt: "What's my pipeline coverage versus a 250k quarterly quota, and is it enough?"
+    why: "Non-obvious: coverage ratio = qualified pipeline / target, read against the segment benchmark (3.5x min / 4-5x target for Commercial). The 'is it enough' verdict is owned here."
+
+  - prompt: "Build me a stage model with exit criteria for a 3-person sales team with no RevOps."
+    why: "Stage-model design — the six gated stages with verifiable buyer-action exit criteria and stage-owned probability is the skill's first artifact."
+
+should_not_trigger:
+  - prompt: "Build a 3-scenario revenue forecast model with monthly seasonality and a cohort projection."
+    route_to: forecasting
+    why: "Statistical/scenario modeling and time-series/cohort projection is the forecasting layer; sales-pipeline only does the simple stage-weighted roll-up."
+
+  - prompt: "Find me 200 prospect companies in fintech with verified emails to add to my pipeline."
+    route_to: lead-gen
+    why: "Sourcing/qualifying NEW prospects is lead-gen; sales-pipeline operates on deals that already exist in the list."
+
+  - prompt: "Write the cold email sequence to contact these prospects and book meetings."
+    route_to: cold-outreach
+    why: "Writing the outbound copy and cadence is cold-outreach; sales-pipeline schedules the next step but does not write the words."
+
+  - prompt: "Draft the proposal and quote for the deal we just qualified."
+    route_to: proposals
+    why: "The proposal/quote/SOW document is owned by proposals; a stage transition is not a document."
+
+  - prompt: "We just closed the deal — set up the client kickoff and account onboarding."
+    route_to: client-onboarding
+    why: "Post-close handoff, kickoff, and account setup is client-onboarding; a Closed-Won deal leaves this skill."
+
+capability:
+  - scenario: "Given a 6-row deal CSV with mixed staleness, some hand-set win_probs, and missing next steps, produce a cleaned pipeline (stage-owned probabilities, recomputed weighted_value), a flagged-stale list, a weekly follow-up list, a weighted forecast, and coverage versus a stated quota."
+    must_include:
+      - "Applies the required-field gate: flags every open deal missing next_step, close_date, or last_touch as a defect."
+      - "Resets win_prob to the stage default (probability owned by the stage, not hand-set per deal) and recomputes weighted_value = value x win_prob."
+      - "Flags stale deals by the activity-decay rules: halve weight at 14+ days no touch, exclude from coverage at 30+ days."
+      - "Flags deals sitting > 1.5x the average time-in-stage, and any open deal with a past close_date."
+      - "Weighted forecast = sum(value x stage win_prob) after stale decay, not list-price sum."
+      - "Coverage = qualified (non-stale) pipeline / target, with a verdict against the segment benchmark (e.g. 3.5x min / 4-5x target for Commercial)."
+      - "Uses the current ~18% win rate / real cycle length, not an optimistic last-year number."
+      - "Emits an artifact (CSV or markdown table) with the required columns that scripts/verify.sh can lint, plus a coverage summary line."
+      - "Routes statistical/scenario modeling to forecasting rather than attempting it inline."

package/skills/sales-pipeline/references/forecasting-math.md

@@ -0,0 +1,82 @@
+# Forecasting math — worked examples and the column contract
+
+This is the simple stage-weighted roll-up that falls out of a clean pipeline.
+It is **not** statistical forecasting — no scenarios, no time-series, no cohort
+projection. If the ask needs those, route to `forecasting`.
+
+All figures use the load-bearing benchmarks: stage probabilities from the stage
+model, the current **~18% B2B win rate** (down from ~21%, with cycles ~12%
+longer YoY — *Ebsta/Pavilion 2025 B2B Sales Benchmark*), and the segment
+coverage benchmarks below. *(Drivetrain / Coefficient / forecastio.ai; ORM Tech;
+First Page Sage — all accessed 2026-06-02.)*
+
+## 1 — Weighted forecast on a 5-deal list
+
+`weighted_value = value × stage win_prob`, then apply stale decay (no touch
+14+ days → halve; 30+ days → drop from the roll-up).
+
+| id | value | stage | win_prob | last_touch age | adjustment | weighted |
+|---|---|---|---|---|---|---|
+| D-1 | 40,000 | Discovery | 0.30 | 3 d | none | 12,000 |
+| D-2 | 25,000 | Negotiation | 0.65 | 6 d | none | 16,250 |
+| D-3 | 60,000 | Proposal | 0.40 | 18 d | halve (14d+) | 12,000 |
+| D-4 | 30,000 | Qualification | 0.10 | 40 d | **drop** (30d+) | 0 |
+| D-5 | 50,000 | Negotiation | 0.65 | 2 d | none | 32,500 |
+
+- Raw weighted (no decay): 12,000 + 16,250 + 24,000 + 3,000 + 32,500 = **87,750**.
+- Decayed weighted forecast: 12,000 + 16,250 + 12,000 + 0 + 32,500 = **72,750**.
+
+The 15,000 gap is exactly the cost of stale deals — which is why you decay
+before you report, never after.
+
+## 2 — Pipeline coverage by segment
+
+`coverage = Total Qualified Pipeline Value ÷ Revenue Target`. "Qualified"
+excludes stale (30d+) deals.
+
+| segment | win rate | min | target |
+|---|---|---|---|
+| Enterprise ($100K+ ACV) | 15–20% | 5× | 6–7× |
+| Commercial ($25–100K) | 20–30% | 3.5× | 4–5× |
+| SMB (<$25K) | 30–40% | 2.5× | 3–4× |
+
+*(ORM Tech, accessed 2026-06-02.)*
+
+**Worked:** a Commercial team with a $250K quarterly target and $900K of
+qualified (non-stale) pipeline has coverage = 900 / 250 = **3.6×**. That clears
+the 3.5× minimum but sits below the 4–5× target — adequate, not comfortable.
+If coverage drops two weeks running with no closes, escalate; that is the red
+flag, not a single low snapshot.
+
+## 3 — Pipeline velocity
+
+`velocity = (Open opps × Avg deal size × Win rate) ÷ Sales-cycle length (days)`
+→ dollars/day. *(Salesmotion / ORM Tech.)*
+
+**Worked:** 40 open opps × $30,000 avg × 0.18 win ÷ 90-day cycle =
+216,000 / 90 = **$2,400/day**.
+
+Cycle length is the highest-leverage term: cut the 90-day cycle ~20% to 72 days
+and velocity rises to 216,000 / 72 = **$3,000/day** — a ~25% lift from one
+lever. Use your **real, current** cycle length; a shorter historical cycle
+flatters the number the same way an old win rate does.
+
+## 4 — The column contract `verify.sh` enforces
+
+The pipeline artifact (CSV or markdown table) must have a header containing at
+least these columns; `verify.sh` is a structural + arithmetic lint over them,
+not a judgement of deal quality.
+
+| column | check |
+|---|---|
+| `stage` | present in header; each value in the allowed set: Prospecting, Qualification, Discovery, Proposal/Demo (or Proposal / Demo), Negotiation, Closed (Won/Lost) |
+| `value` | present; numeric |
+| `win_prob` | present; `0 ≤ win_prob ≤ 1` |
+| `weighted_value` | present; equals `round(value × win_prob)` within tolerance |
+| `close_date` | present and non-empty on every **open** deal |
+| `next_step` | present and non-empty on every **open** deal |
+| `last_touch` | present and non-empty on every **open** deal |
+
+Plus: at least one **coverage** summary line/row must be present somewhere in
+the file (a line matching `coverage`). An empty or missing-content file is a
+clean pass — the lint never false-fails on nothing.

package/skills/sales-pipeline/references/stage-playbook.md

@@ -0,0 +1,84 @@
+# Stage playbook — the six gated stages in full
+
+The default model is six stages. Five stages with clear exit criteria beat nine
+stages with none. A deal advances **only** when the exit criterion (a verifiable
+buyer action) is met **and** a next step is on the calendar. The stage carries
+the win-probability; the rep never hand-sets it. *(Cirrus Insight / Prospeo,
+accessed 2026-06-02.)*
+
+## The stages
+
+### 1 — Prospecting · default win_prob 0.05
+- **Exit criterion:** the buyer has agreed to a first real conversation — a
+  meeting is on the calendar (not "they opened my email").
+- **Required fields:** `id`, `company`, `owner`, `next_step` (the meeting),
+  `last_touch`.
+- A deal here is barely a deal; do not let Prospecting volume flatter coverage.
+
+### 2 — Qualification · default win_prob 0.10
+- **Exit criterion:** BANT (or MEDDIC above ~$25K ACV) documented as a "yes" —
+  budget exists, you are talking to or have a path to authority, there is a real
+  need, and there is a timeline.
+- **Required fields:** add `value` (first real estimate), `close_date` (first
+  estimate), the qualification notes.
+
+### 3 — Discovery · default win_prob 0.30
+- **Exit criterion:** the buyer has confirmed the problem and their success
+  criteria, and you know the **buying process** — review layers, legal steps,
+  procurement. "If you don't know the criteria, timeline, review layers and
+  legal steps, the close date is a guess." *(Routine / weflow / HubSpot.)*
+- **Required fields:** firmed `value`, firmed `close_date`, the buying-process
+  notes, `next_step`.
+
+### 4 — Proposal/Demo · default win_prob 0.40
+- **Exit criterion:** the proposal or demo has been delivered **and
+  acknowledged**, and the buyer is engaging on it (questions, redlines, internal
+  circulation) — not just "sent and silent."
+- The proposal document itself is written by `proposals`, not here.
+
+### 5 — Negotiation · default win_prob 0.65 (band 0.50–0.80)
+- **Exit criterion:** terms and price are under active discussion, there is
+  verbal intent, and you have a **mutual close plan** with dates.
+- Pick within the 0.50–0.80 band on real signal (legal in motion, MSA in
+  redline → higher end). Never reflexively set 0.80.
+
+### 6 — Closed · win_prob 1.0 (Won) / 0.0 (Lost)
+- **Won:** signed. The deal leaves this skill — handoff/kickoff is
+  `client-onboarding`.
+- **Lost:** formally lost, with a reason. Losing cleanly keeps the win-rate
+  honest; do not let dead deals linger as "open."
+
+## Qualification: BANT vs MEDDIC — pick by deal size
+
+Run **BANT as a ~60-second screen** on every deal; switch to **MEDDIC/SPICED
+above ~$25K ACV** where the buying process is complex enough to need it.
+*(Routine / weflow / HubSpot, accessed 2026-06-02.)*
+
+| | BANT (fast screen, < $25K) | MEDDIC (complex, $25K+ ACV) |
+|---|---|---|
+| B / M | **B**udget | **M**etrics — the quantified business outcome |
+| A / E | **A**uthority | **E**conomic buyer — who signs |
+| N / D | **N**eed | **D**ecision criteria + **D**ecision process |
+| T / I | **T**imeline | **I**dentify pain + **C**hampion |
+
+The exit criterion for Qualification is a documented "yes" across the relevant
+framework **plus** a calendared next step. A "yes" with no next step is not a
+pass.
+
+## Forecast categories — map separately from stages
+
+Categories are a judgement of *confidence to land this period*; stages are
+*where the deal is in the process*. They are not the same axis. *(Gary Smith
+Partnership / Salesforce default categories, accessed 2026-06-02.)*
+
+| category | meaning | rough in-quarter landing |
+|---|---|---|
+| Pipeline | open, qualified, not yet committed | ~25% lands this quarter |
+| Best Case | upside if things go well | ~1/3 to 1/2 lands |
+| Commit | you are willing to put your name on it | near-all lands |
+| Closed | signed (Won) or lost | done |
+| Omitted | excluded from the forecast (e.g. stale 30d+) | not counted |
+
+Rule: a deal's category must match documented evidence. A Discovery-stage deal
+in "Commit" is a defect — demote it. Stale deals (30+ days no touch) move to
+Omitted so they stop flattering the commit number.

package/skills/sales-pipeline/scripts/verify.sh

@@ -0,0 +1,210 @@
+#!/usr/bin/env bash
+#
+# verify.sh — structural + arithmetic lint for a pipeline file.
+#
+# WHAT IT DOES (read-only; never edits or writes a file)
+#   Static, network-free checks over ONE pipeline file you point it at — a CSV
+#   (preferred) or a markdown table with the same column names:
+#     1. Header has the required columns: id, value, stage, win_prob,
+#        weighted_value, close_date, next_step, last_touch.  (missing -> FAIL)
+#     2. Each non-Closed (open) deal has non-empty close_date, next_step,
+#        last_touch.                                          (missing -> FAIL)
+#     3. stage is in the allowed set: Prospecting, Qualification, Discovery,
+#        Proposal/Demo (or "Proposal"/"Demo"), Negotiation, Closed
+#        (incl. "Closed Won" / "Closed Lost").                (unknown -> FAIL)
+#     4. win_prob is a number with 0 <= win_prob <= 1.        (out of range -> FAIL)
+#     5. weighted_value == round(value * win_prob) within +/-1 tolerance.
+#                                                             (mismatch -> FAIL)
+#     6. A coverage summary line/row is present somewhere (a line matching
+#        /coverage/i).                                         (absent -> FAIL)
+#
+#   A clean OR empty/missing-content file exits 0 — never a false failure.
+#
+# HOW TO RUN (inside YOUR project, not the skills repo)
+#   ./verify.sh pipeline.csv          # lint a CSV pipeline
+#   ./verify.sh pipeline.md           # lint a markdown-table pipeline
+#   ./verify.sh pipeline.csv --tol 2  # widen the weighted_value tolerance
+#
+# EXIT CODES
+#   0  clean, or empty/missing-content file
+#   1  one or more structural / arithmetic failures
+#   2  bad usage (no file, file missing, header has no required columns at all)
+#
+# Runs on stock macOS bash 3.2 + awk: no mapfile, no bc, no associative arrays.
+
+set -euo pipefail
+
+if [ -t 1 ]; then
+  RED=$'\033[31m'; GREEN=$'\033[32m'; NC=$'\033[0m'
+else
+  RED=''; GREEN=''; NC=''
+fi
+
+fail_count=0
+ok()   { printf '%s[ ok ]%s %s\n' "$GREEN" "$NC" "$*"; }
+fail() { printf '%s[fail]%s %s\n' "$RED"   "$NC" "$*"; fail_count=$((fail_count + 1)); }
+
+usage() { sed -n '2,33p' "$0" | sed 's/^# \{0,1\}//'; }
+
+FILE=""
+TOL=1
+while [ $# -gt 0 ]; do
+  case "$1" in
+    -h|--help) usage; exit 0 ;;
+    --tol) TOL="${2:-1}"; shift 2 ;;
+    -*) printf '%sunknown option: %s%s\n' "$RED" "$1" "$NC" >&2; usage; exit 2 ;;
+    *) if [ -z "$FILE" ]; then FILE="$1"; fi; shift ;;
+  esac
+done
+
+if [ -z "$FILE" ]; then
+  printf '%sno pipeline file given%s\n' "$RED" "$NC" >&2; usage; exit 2
+fi
+if [ ! -f "$FILE" ]; then
+  printf '%sfile not found: %s%s\n' "$RED" "$FILE" "$NC" >&2; exit 2
+fi
+
+# Empty / whitespace-only file: nothing to check, do not false-fail.
+if [ ! -s "$FILE" ] || ! grep -q '[^[:space:]]' "$FILE" 2>/dev/null; then
+  ok "empty file — nothing to check"
+  exit 0
+fi
+
+printf 'sales-pipeline verify — %s (weighted_value tolerance=+/-%s)\n\n' "$FILE" "$TOL"
+
+# All checks run in one awk pass. It auto-detects delimiter: a pipe-table row
+# (markdown) splits on '|'; otherwise CSV splits on ','. Quotes are tolerated
+# (a quoted field with internal commas is rare in these columns; we strip
+# surrounding quotes and trim spaces). The coverage check scans every raw line.
+awk -v tol="$TOL" '
+  function trim(s){ gsub(/^[ \t"]+/,"",s); gsub(/[ \t"]+$/,"",s); return s }
+  function lc(s){ return tolower(s) }
+
+  # detect coverage line anywhere; a coverage summary row is not a deal row
+  tolower($0) ~ /coverage/ { cov=1; next }
+
+  # skip markdown separator rows like |----|----|
+  /^[ \t]*\|?[ \t:-]+\|[ \t:|-]*$/ { next }
+
+  {
+    raw=$0
+    # choose delimiter
+    if (raw ~ /\|/) { sep="|" } else { sep="," }
+    n=split(raw, f, sep)
+    # markdown tables have a leading/trailing pipe -> empty cells; trim all
+    for (i=1;i<=n;i++) f[i]=trim(f[i])
+
+    # locate header row: the first row containing "stage" and "win_prob"
+    if (!have_header) {
+      isheader=0
+      for (i=1;i<=n;i++) {
+        if (lc(f[i])=="stage") s_seen=1
+        if (lc(f[i])=="win_prob") w_seen=1
+      }
+      if (s_seen && w_seen) {
+        have_header=1
+        for (i=1;i<=n;i++) { col[lc(f[i])]=i }
+        next
+      }
+      s_seen=0; w_seen=0
+      next
+    }
+
+    # data row
+    # skip a row that is empty after trimming (markdown edge cells)
+    nonempty=0
+    for (i=1;i<=n;i++) if (f[i]!="") nonempty=1
+    if (!nonempty) next
+
+    rows++
+    id    = (("id" in col)             ? f[col["id"]] : ("row " rows))
+    stg   = (("stage" in col)          ? f[col["stage"]] : "")
+    val   = (("value" in col)          ? f[col["value"]] : "")
+    wp    = (("win_prob" in col)       ? f[col["win_prob"]] : "")
+    wv    = (("weighted_value" in col) ? f[col["weighted_value"]] : "")
+    cd    = (("close_date" in col)     ? f[col["close_date"]] : "")
+    ns    = (("next_step" in col)      ? f[col["next_step"]] : "")
+    lt    = (("last_touch" in col)     ? f[col["last_touch"]] : "")
+
+    lstg = lc(stg)
+    open_deal = (lstg !~ /closed|won|lost/)
+
+    # 2 — required fields on open deals
+    if (open_deal) {
+      if (cd=="") { print "FAIL\t" id ": open deal missing close_date" ; bad++ }
+      if (ns=="") { print "FAIL\t" id ": open deal missing next_step"  ; bad++ }
+      if (lt=="") { print "FAIL\t" id ": open deal missing last_touch" ; bad++ }
+    }
+
+    # 3 — stage in allowed set
+    allowed = (lstg ~ /^(prospecting|qualification|discovery|proposal\/demo|proposal|demo|negotiation|closed|closed won|closed lost)$/)
+    if (stg!="" && !allowed) { print "FAIL\t" id ": unknown stage \"" stg "\"" ; bad++ }
+
+    # 4 — win_prob numeric in [0,1]
+    if (wp ~ /^[0-9]*\.?[0-9]+$/) {
+      if (wp+0 < 0 || wp+0 > 1) { print "FAIL\t" id ": win_prob " wp " out of range [0,1]" ; bad++ }
+    } else if (wp != "") {
+      print "FAIL\t" id ": win_prob \"" wp "\" is not a number" ; bad++
+    }
+
+    # 5 — weighted_value == round(value * win_prob) within tol
+    if (val ~ /^[0-9]*\.?[0-9]+$/ && wp ~ /^[0-9]*\.?[0-9]+$/ && wv ~ /^[0-9]*\.?[0-9]+$/) {
+      expect = val*wp
+      diff = wv - expect; if (diff<0) diff=-diff
+      if (diff > tol) {
+        print "FAIL\t" id ": weighted_value " wv " != value*win_prob (" expect ")"
+        bad++
+      }
+    }
+  }
+  END {
+    if (!have_header) { print "NOHEADER" ; exit 0 }
+    print "META\t" rows "\t" bad+0 "\t" cov+0
+  }
+' "$FILE" > /tmp/sp_verify.$$ 2>/dev/null || true
+
+# Replay awk output into the colored reporter.
+NOHEADER=0; ROWS=0; BAD=0; COV=0
+while IFS=$'\t' read -r kind a b c; do
+  case "$kind" in
+    FAIL) fail "$a" ;;
+    NOHEADER) NOHEADER=1 ;;
+    META) ROWS="$a"; BAD="$b"; COV="$c" ;;
+  esac
+done < /tmp/sp_verify.$$
+rm -f /tmp/sp_verify.$$
+
+if [ "$NOHEADER" -eq 1 ]; then
+  printf '%sno header row with the required columns (need at least stage + win_prob)%s\n' "$RED" "$NC" >&2
+  exit 2
+fi
+
+# 1 — required columns reported only if a deal referenced a missing one is moot;
+# we re-derive column presence cheaply from the header line.
+HEADER_LINE="$(grep -iE 'win_prob' "$FILE" | head -1)"
+for c in id value stage win_prob weighted_value close_date next_step last_touch; do
+  if printf '%s' "$HEADER_LINE" | grep -iqw "$c"; then
+    :
+  else
+    fail "required column missing from header: $c"
+  fi
+done
+
+# 6 — coverage summary present
+if [ "$COV" -eq 1 ]; then
+  ok "coverage summary line present"
+else
+  fail "no coverage summary line found (need a line matching /coverage/)"
+fi
+
+if [ "${ROWS:-0}" -gt 0 ] && [ "${BAD:-0}" -eq 0 ]; then
+  ok "$ROWS deal row(s) — fields, stages, win_prob and weighted_value all valid"
+fi
+
+printf '\n'
+if [ "$fail_count" -gt 0 ]; then
+  printf '%s%d failure(s)%s\n' "$RED" "$fail_count" "$NC"
+  exit 1
+fi
+printf '%sall checks passed%s\n' "$GREEN" "$NC"
+exit 0