skilldrop-cli 1.8.0 → 1.10.0

package/packs/startup-legal/skills/cap-table/scripts/cap_table.py

@@ -0,0 +1,344 @@
+#!/usr/bin/env python3
+"""Model a startup's ownership through SAFEs, convertible notes and a priced round. Stdlib only.
+
+Reads a cap.json: the shareholders, the option pool, every SAFE and convertible note, and
+(optionally) the priced round's pre-money valuation, new money and target option pool. Prints:
+  - the fully diluted cap table today, and what the SAFEs already promise at their caps
+  - each SAFE's and note's conversion price, and whether its cap or its discount applied
+  - the price per share, the option pool top-up, and the cap table after the round
+  - founder ownership at other pre-money valuations (--scenarios)
+and checks that the post-money valuation equals price per share × fully diluted shares and
+that ownership sums to 100 %.
+
+Conventions (printed with every result, because term sheets differ):
+  - post-money SAFE (YC 2018+): capitalization for its cap price includes every share,
+    option, the existing unissued pool and all converting securities, but not the pool
+    increase made in the round
+  - pre-money SAFE and convertible note: cap price = cap ÷ (existing fully diluted shares +
+    the pool increase), excluding converting securities
+  - the pool top-up is in the pre-money ("option pool shuffle"): the unissued pool after the
+    round is the target share of post-money fully diluted shares
+  - note interest is simple, from its issue date to the closing date; shares round down
+
+Usage:
+  python3 cap_table.py cap.json [--scenarios 8000000,12000000] [--csv after.csv] [--json]
+Exit codes: 0 computed, 1 a check failed or the round cannot be modelled, 2 bad input.
+"""
+import argparse
+import csv
+import datetime as dt
+import json
+import math
+import sys
+
+
+class InputError(Exception):
+    pass
+
+
+def num(v, what, lo=0.0, allow_none=False):
+    if v is None and allow_none:
+        return None
+    if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v) or v < lo:
+        raise InputError(f"{what} must be a number of at least {lo:g}")
+    return float(v)
+
+
+def frac(v, what):
+    """A rate given as 0.2 or 20 (meaning 20 %)."""
+    if v is None:
+        return 0.0
+    v = num(v, what)
+    if v >= 1:
+        v /= 100
+    if v >= 1:
+        raise InputError(f"{what} must be under 100 %")
+    return v
+
+
+def date(v, what):
+    if v is None:
+        return None
+    try:
+        return dt.date.fromisoformat(str(v))
+    except ValueError:
+        raise InputError(f"{what} must be a date as YYYY-MM-DD")
+
+
+def load(data):
+    if not isinstance(data, dict):
+        raise InputError("cap.json must be a JSON object")
+    holders = []
+    for i, h in enumerate(data.get("holders") or [], 1):
+        if not isinstance(h, dict) or not str(h.get("name", "")).strip():
+            raise InputError(f"holder {i} needs a `name`")
+        holders.append({"name": str(h["name"]).strip(), "class": str(h.get("class", "common")),
+                        "shares": num(h.get("shares"), f"{h['name']}: shares")})
+    if not holders:
+        raise InputError("`holders` must list at least one shareholder with shares")
+    opts = data.get("options") or {}
+    if not isinstance(opts, dict):
+        raise InputError("`options` must be an object with `granted` and `pool_unissued`")
+    granted = num(opts.get("granted", 0), "options.granted")
+    unissued = num(opts.get("pool_unissued", 0), "options.pool_unissued")
+    convs = []
+    for kind, key in (("safe", "safes"), ("note", "notes")):
+        for i, s in enumerate(data.get(key) or [], 1):
+            if not isinstance(s, dict) or not str(s.get("holder", "")).strip():
+                raise InputError(f"{kind} {i} needs a `holder`")
+            name = str(s["holder"]).strip()
+            c = {"kind": kind, "holder": name,
+                 "cap": num(s.get("cap"), f"{name}: cap", 1, allow_none=True),
+                 "discount": frac(s.get("discount"), f"{name}: discount"),
+                 "mfn": bool(s.get("mfn", False))}
+            if kind == "safe":
+                c["amount"] = num(s.get("amount"), f"{name}: amount", 1)
+                basis = str(s.get("type", "post")).lower()
+                if basis not in ("post", "pre"):
+                    raise InputError(f"{name}: SAFE type must be \"post\" or \"pre\"")
+                c["basis"] = basis
+            else:
+                c["principal"] = num(s.get("principal"), f"{name}: principal", 1)
+                c["rate"] = frac(s.get("rate"), f"{name}: rate")
+                c["issued"] = date(s.get("issued"), f"{name}: issued")
+                c["basis"] = "pre"
+            convs.append(c)
+    rnd = data.get("round")
+    if rnd is not None:
+        if not isinstance(rnd, dict):
+            raise InputError("`round` must be an object")
+        inv = []
+        for i, x in enumerate(rnd.get("investors") or [], 1):
+            if not isinstance(x, dict) or not str(x.get("name", "")).strip():
+                raise InputError(f"round investor {i} needs a `name`")
+            inv.append({"name": str(x["name"]).strip(), "amount": num(x.get("amount"), f"{x['name']}: amount", 1)})
+        if not inv:
+            raise InputError("`round.investors` must list who puts in the new money")
+        pool_in = str(rnd.get("pool_in", "pre")).lower()
+        if pool_in not in ("pre", "post"):
+            raise InputError("round.pool_in must be \"pre\" (top-up in the pre-money, the usual term) or \"post\"")
+        rnd = {"pre_money": num(rnd.get("pre_money"), "round.pre_money", 1),
+               "investors": inv, "pool_target": frac(rnd.get("pool_target"), "round.pool_target"),
+               "pool_in": pool_in, "close": date(rnd.get("close"), "round.close")}
+    return {"company": str(data.get("company", "The company")), "currency": str(data.get("currency", "USD")),
+            "holders": holders, "granted": granted, "unissued": unissued, "convs": convs, "round": rnd}
+
+
+def note_amount(c, close, warns):
+    if c["kind"] != "note":
+        return c["amount"]
+    if c["rate"] and (c["issued"] is None or close is None):
+        warns.append(f"{c['holder']}: note interest not counted; give `issued` and the round's `close` date")
+        return c["principal"]
+    years = max(0.0, (close - c["issued"]).days / 365) if c["issued"] and close else 0.0
+    return c["principal"] * (1 + c["rate"] * years)
+
+
+def today_fd(cap):
+    return sum(h["shares"] for h in cap["holders"]) + cap["granted"] + cap["unissued"]
+
+
+def model(cap, pre_money=None):
+    """Solve the round. Returns None when there is no round to model."""
+    rnd = cap["round"]
+    if rnd is None:
+        return None
+    pre = pre_money if pre_money is not None else rnd["pre_money"]
+    warns = []
+    base = today_fd(cap)
+    amounts = [note_amount(c, rnd["close"], warns) for c in cap["convs"]]
+    new_money = sum(x["amount"] for x in rnd["investors"])
+    conv_shares = [0.0] * len(cap["convs"])
+    pool_inc = 0.0
+    price = pre / base
+    in_pre = rnd["pool_in"] == "pre"
+    for _ in range(500):
+        conv_total = sum(conv_shares)
+        pre_fd = base + conv_total + (pool_inc if in_pre else 0)
+        price = pre / pre_fd
+        new = []
+        how = []
+        for c, amt in zip(cap["convs"], amounts):
+            cands = {"round price": price}
+            if c["discount"]:
+                cands["discount"] = price * (1 - c["discount"])
+            if c["cap"]:
+                denom = base + conv_total if c["basis"] == "post" else base + pool_inc
+                cands["cap"] = c["cap"] / denom
+            pick = min(cands, key=cands.get)
+            new.append(amt / cands[pick])
+            how.append((pick, cands[pick]))
+        post_fd = pre_fd + new_money / price + (0 if in_pre else pool_inc)
+        new_pool = max(0.0, rnd["pool_target"] * post_fd - cap["unissued"])
+        delta = max(abs(a - b) for a, b in zip(new + [new_pool], conv_shares + [pool_inc])) if new else abs(new_pool - pool_inc)
+        conv_shares, pool_inc = new, new_pool
+        if delta < 1e-6:
+            break
+    else:
+        return {"error": "the round does not settle: the SAFEs' caps leave no room for the new money at this valuation"}
+    conv_total = sum(conv_shares)
+    pre_fd = base + conv_total + (pool_inc if in_pre else 0)
+    price = pre / pre_fd
+    rows = [{"name": h["name"], "class": h["class"], "shares": h["shares"]} for h in cap["holders"]]
+    convs = []
+    for c, amt, sh, (pick, p) in zip(cap["convs"], amounts, conv_shares, how):
+        shares = math.floor(sh + 1e-9)
+        convs.append({"holder": c["holder"], "kind": c["kind"], "basis": c["basis"], "invested": amt,
+                      "price": p, "by": pick, "shares": shares, "mfn": c["mfn"]})
+        rows.append({"name": c["holder"], "class": f"preferred ({c['kind']})", "shares": shares})
+    investors = []
+    for x in rnd["investors"]:
+        shares = math.floor(x["amount"] / price + 1e-9)
+        investors.append({"name": x["name"], "amount": x["amount"], "shares": shares})
+        rows.append({"name": x["name"], "class": "preferred (round)", "shares": shares})
+    rows.append({"name": "Options granted", "class": "options", "shares": cap["granted"]})
+    pool_after = math.floor(cap["unissued"] + pool_inc + 1e-9)
+    rows.append({"name": "Option pool, unissued", "class": "options", "shares": pool_after})
+    total = sum(r["shares"] for r in rows)
+    for r in rows:
+        r["pct"] = r["shares"] / total * 100
+    post_val = price * total
+    for c in cap["convs"]:
+        if c["mfn"] and not c["cap"] and not c["discount"]:
+            warns.append(f"{c['holder']}: an MFN SAFE with no terms of its own converts at the round price here; "
+                         "check whether a later SAFE's cap or discount applies to it")
+    fails = []
+    if abs(sum(r["pct"] for r in rows) - 100) > 1e-6:
+        fails.append("ownership does not sum to 100 %")
+    expected = pre + new_money + (0 if in_pre else (pool_after - cap["unissued"]) * price)
+    if abs(post_val - expected) / expected > 0.001:
+        fails.append(f"post-money {post_val:,.0f} is not pre-money + new money {expected:,.0f}")
+    return {"pre_money": pre, "new_money": new_money, "price": price, "pool_increase": pool_after - cap["unissued"],
+            "pool_after": pool_after, "convs": convs, "investors": investors, "rows": rows, "total": total,
+            "post_money": post_val, "pool_in": rnd["pool_in"],
+            "effective_pre": pre - ((pool_after - cap["unissued"]) * price if in_pre else 0),
+            "warns": warns, "fails": fails}
+
+
+def stack(cap):
+    """What the post-money SAFEs already promise: amount ÷ cap each, before any round."""
+    out = []
+    for c in cap["convs"]:
+        if c["kind"] == "safe" and c["basis"] == "post" and c["cap"]:
+            out.append((c["holder"], c["amount"], c["cap"], c["amount"] / c["cap"]))
+    return out
+
+
+def money(v, cur):
+    sym = {"USD": "$", "EUR": "€", "GBP": "£", "INR": "₹"}.get(cur.upper(), "")
+    return f"{sym}{v:,.0f}" if sym else f"{v:,.0f} {cur}"
+
+
+def report(cap, r, scen):
+    cur = cap["currency"]
+    L = [f"# {cap['company']}: cap table", "", "## Today, fully diluted", "",
+         "| Holder | Class | Shares | % |", "|---|---|---:|---:|"]
+    base = today_fd(cap)
+    for h in cap["holders"]:
+        L.append(f"| {h['name']} | {h['class']} | {h['shares']:,.0f} | {h['shares'] / base * 100:.2f} |")
+    L.append(f"| Options granted | options | {cap['granted']:,.0f} | {cap['granted'] / base * 100:.2f} |")
+    L.append(f"| Option pool, unissued | options | {cap['unissued']:,.0f} | {cap['unissued'] / base * 100:.2f} |")
+    L.append(f"| **Total** | | **{base:,.0f}** | **100.00** |")
+    st = stack(cap)
+    if st:
+        L += ["", "Post-money SAFEs already promise, at their caps (amount ÷ cap):", ""]
+        for name, amt, capv, share in st:
+            L.append(f"- {name}: {money(amt, cur)} ÷ {money(capv, cur)} = {share * 100:.2f} %")
+        tot = sum(s[3] for s in st)
+        L.append(f"- **Together: {tot * 100:.2f} %** of the company before the round's new money and pool top-up")
+    if r is None:
+        L += ["", "No priced round given, so nothing converts yet."]
+        return "\n".join(L) + "\n"
+    if "error" in r:
+        L += ["", f"FAIL {r['error']}"]
+        return "\n".join(L) + "\n"
+    L += ["", "## The round", "",
+          f"- Pre-money valuation: {money(r['pre_money'], cur)}; new money: {money(r['new_money'], cur)}; "
+          f"post-money: {money(r['post_money'], cur)}",
+          f"- Price per share: {r['price']:.4f}",
+          f"- Option pool top-up ({'in the pre-money' if r['pool_in'] == 'pre' else 'after the round, diluting the new investors too'}): "
+          f"{r['pool_increase']:,.0f} shares, unissued pool after: {r['pool_after']:,.0f} "
+          f"({r['pool_after'] / r['total'] * 100:.2f} % post-money)",
+          f"- Effective pre-money for existing holders, after the pool top-up: {money(r['effective_pre'], cur)}"]
+    if r["convs"]:
+        L += ["", "| SAFE or note | Invested (with interest) | Converts at | By | Shares |", "|---|---:|---:|---|---:|"]
+        for c in r["convs"]:
+            L.append(f"| {c['holder']} ({c['basis']}-money {c['kind']}) | {money(c['invested'], cur)} | "
+                     f"{c['price']:.4f} | {c['by']} | {c['shares']:,.0f} |")
+    L += ["", "## After the round, fully diluted", "", "| Holder | Class | Shares | % |", "|---|---|---:|---:|"]
+    for row in r["rows"]:
+        L.append(f"| {row['name']} | {row['class']} | {row['shares']:,.0f} | {row['pct']:.2f} |")
+    L.append(f"| **Total** | | **{r['total']:,.0f}** | **100.00** |")
+    if scen:
+        L += ["", "## At other pre-money valuations", "",
+              "| Pre-money | Price per share | " + " | ".join(h["name"] for h in cap["holders"]) + " | New investors |",
+              "|---:|---:|" + "---:|" * (len(cap["holders"]) + 1)]
+        for v in scen:
+            s = model(cap, v)
+            if s is None or "error" in s:
+                L.append(f"| {money(v, cur)} | cannot settle | " + " | " * len(cap["holders"]) + " |")
+                continue
+            pct = {row["name"]: row["pct"] for row in s["rows"]}
+            inv = sum(pct[x["name"]] for x in s["investors"])
+            L.append(f"| {money(v, cur)} | {s['price']:.4f} | " + " | ".join(f"{pct[h['name']]:.2f} %" for h in cap["holders"])
+                     + f" | {inv:.2f} % |")
+    L += ["", "Conventions: post-money SAFEs exclude the round's pool top-up from their cap price; pre-money SAFEs "
+          "and notes divide their cap by existing shares plus the top-up; the top-up is in the pre-money; note "
+          "interest is simple; shares round down."]
+    for f in r["fails"]:
+        L.append(f"FAIL {f}")
+    for w in r["warns"]:
+        L.append(f"WARN {w}")
+    return "\n".join(L) + "\n"
+
+
+def parse_scenarios(text):
+    """'8m,12m', '8000000 12000000' or '8M;12.5M' -> [8e6, 12e6]."""
+    out = []
+    for tok in text.replace(";", " ").replace(",", " ").split():
+        t = tok.strip().lower().lstrip("$€£₹")
+        mult = {"k": 1e3, "m": 1e6, "b": 1e9}.get(t[-1:], 1)
+        if mult != 1:
+            t = t[:-1]
+        try:
+            out.append(num(float(t) * mult, "scenario", 1))
+        except ValueError:
+            raise InputError(f"scenario {tok!r} is not a valuation; write 8m or 8000000")
+    return out
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="Model ownership through SAFEs, notes and a priced round.")
+    ap.add_argument("cap")
+    ap.add_argument("--scenarios", help="comma-separated pre-money valuations to compare")
+    ap.add_argument("--csv", help="write the cap table after the round here")
+    ap.add_argument("--json", action="store_true", help="print the figures as JSON")
+    args = ap.parse_args(argv)
+    try:
+        with open(args.cap, encoding="utf-8-sig") as f:
+            cap = load(json.load(f))
+        scen = parse_scenarios(args.scenarios) if args.scenarios else []
+    except (OSError, ValueError, UnicodeDecodeError) as e:
+        print(f"FAIL cannot read input: {e}")
+        return 2
+    except InputError as e:
+        print(f"FAIL {e}")
+        return 2
+    r = model(cap)
+    if args.json:
+        print(json.dumps({"today_fd": today_fd(cap), "safe_stack": stack(cap), "round": r}, indent=2, default=str))
+    else:
+        print(report(cap, r, scen), end="")
+    if args.csv and r and "error" not in r:
+        with open(args.csv, "w", encoding="utf-8", newline="") as f:
+            w = csv.writer(f)
+            w.writerow(["Holder", "Class", "Shares", "Percent"])
+            for row in r["rows"]:
+                w.writerow([row["name"], row["class"], int(row["shares"]), f"{row['pct']:.4f}"])
+    if r and ("error" in r or r["fails"]):
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/packs/startup-legal/skills/cap-table/templates/cap.json

@@ -0,0 +1,23 @@
+{
+  "company": "Example Labs, Inc.",
+  "currency": "USD",
+  "holders": [
+    {"name": "Founder A", "class": "common", "shares": 4500000},
+    {"name": "Founder B", "class": "common", "shares": 4500000}
+  ],
+  "options": {"granted": 250000, "pool_unissued": 750000},
+  "safes": [
+    {"holder": "Angel syndicate", "amount": 500000, "type": "post", "cap": 8000000},
+    {"holder": "Accelerator", "amount": 125000, "type": "post", "cap": 6000000, "discount": 0.2},
+    {"holder": "Early angel", "amount": 100000, "type": "pre", "cap": 5000000, "discount": 0.2}
+  ],
+  "notes": [
+    {"holder": "Friends and family note", "principal": 50000, "rate": 0.06, "issued": "2025-06-01", "cap": 5000000, "discount": 0.2}
+  ],
+  "round": {
+    "pre_money": 16000000,
+    "investors": [{"name": "Series A lead", "amount": 4000000}, {"name": "Series A follow-on", "amount": 1000000}],
+    "pool_target": 0.10,
+    "close": "2026-12-15"
+  }
+}

package/packs/startup-legal/skills/contract-check/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: contract-check
+description: Check an agreement before a founder signs or sends it — a script finds the mechanical faults a read-through misses (blanks left in, cross-references to clauses or exhibits that don't exist, numbering that skips, terms defined twice or used undefined, amounts in words that disagree with the figures, dates that don't exist, and the date notice must be given to stop an auto-renewal) — then reads it for the terms that hurt a small company: uncapped liability, one-sided indemnities, IP that leaves, exclusivity, auto-renewal, payment and termination traps. Use when a founder says "review this contract before I sign", "check this NDA / MSA / SaaS agreement / consulting agreement", "anything wrong with this agreement", "what should I push back on", or "is this ready to send".
+---
+
+# contract-check
+
+A small company signs agreements without a lawyer on every one: a customer's MSA, a vendor's
+order form, an NDA, a contractor's agreement. Two kinds of fault hurt it. **Mechanical ones**
+that a read-through misses, because the eye reads what the drafter meant: a clause that
+survives termination by reference to a section that was renumbered away, a fee left as `[●]`,
+"thirty (60) days". A script finds every one, with its line. **Commercial ones** a founder
+doesn't know to look for: liability uncapped one way and capped the other, the founder's IP
+assigned to a customer, an auto-renewal with a notice window that has already passed. The
+agent reads for those, from the founder's side.
+
+## How to respond
+
+**These rules come before the steps and outrank them:**
+
+- **Lead with the verdict and the few things that matter.** ✅ *"Don't sign it as is. Three
+  things: liability is uncapped for you and capped at three months' fees for them (6.1), the
+  fee is still a blank (3.1), and 8.2 says Section 14.3 survives termination, but there is no
+  14.3."* Then the rest. Never mention a script, this skill's name, or a path inside its folder, never call your work "the check" or "a tool", and never show a temporary path.
+- **Every mechanical finding comes from the check,** with its clause number. Never claim a
+  cross-reference is broken, or a term undefined, from a read alone.
+- **Read for the founder's side.** Say who the founder is in the agreement (customer,
+  supplier, discloser) before judging a clause; a one-sided clause is a problem only if it
+  cuts against them. Ask once if the document doesn't make it clear.
+- **For each problem, give the fix as words to send.** ✅ *"Ask for: 'Each party's total
+  liability is limited to the fees paid in the 12 months before the claim.'"* A founder can
+  paste that into a redline or an email.
+- **Name what is worth a lawyer's hour, and only that.** One or two lines, for the clauses
+  where a mistake is expensive or the law differs by country (IP assignment, non-competes,
+  indemnities with no cap, personal guarantees). Never refuse, never open with a disclaimer.
+- **Their document is never overwritten.** A corrected or marked-up copy goes beside it under
+  a plain name (`agreement-marked-up.docx` or `.md`), and only when asked for. Working files
+  go in a private temporary folder (`mktemp -d`) and are deleted before replying.
+
+1. **Find out the deal.** From the document and the conversation: who the founder's company
+   is in it, what it is buying or selling, the money, and the date they expect to sign. If the
+   current term's end date is known, keep it for step 2.
+
+2. **Run the check.** It reads Markdown, plain text and Word files.
+
+   ```bash
+   # Claude Code
+   python3 "${CLAUDE_SKILL_DIR}/scripts/contract_check.py" ./agreement.docx --term-end 2027-07-01
+   # Other IDEs (from the skill folder)
+   python3 scripts/contract_check.py ./agreement.docx
+   ```
+
+   Exit 0 means no failures, 1 means a failure, 2 means the file can't be read (a PDF: convert
+   it to text first). It fails on blanks, broken cross-references, repeated clause numbers,
+   terms defined twice, amounts whose words and figures disagree, and impossible dates. It
+   warns on skipped numbering, defined terms never used or used in lower case, and roles used
+   as defined terms but never defined (*"the Client"* in an agreement that defines *"the
+   Customer"*). It lists every notice period and, with `--term-end`, the last day to give each
+   renewal notice. A warning stands in the reply only if it matters to this deal.
+
+3. **Read the agreement for the founder,** clause by clause, against
+   [`reference.md`](reference.md): liability and its cap, indemnities, IP ownership and
+   licences, confidentiality, payment terms and late fees, term, renewal and termination,
+   exclusivity and non-solicitation, data protection, governing law and disputes, assignment
+   and change of control. For each problem, the clause, why it hurts this founder, and the
+   wording to ask for. Mark severity: 🟥 don't sign as is, 🟧 push back, 🟨 worth asking.
+
+4. **Reply in this order:**
+   1. **The verdict** in one line (sign, sign after these fixes, don't sign), and the three
+      things that matter most.
+   2. **Fixes before signing,** most severe first: clause, the problem, the wording to ask for.
+   3. **Mechanical faults to correct,** one line each with the clause, from the check.
+   4. **Dates to diarise:** each notice deadline, renewal and payment date.
+   5. **What to have a lawyer look at,** one or two lines, only where it's earned.
+
+**Non-interactive runs** (subagent, CI, headless): when the founder's side isn't stated, take
+it from the document's parties and the file's location, tag it `[assumption]`, and read from
+that side. With no agreement supplied, emit `BLOCKED: need the agreement (as .docx, .md or
+.txt)`.
+
+## Useful references in this skill
+
+- [`reference.md`](reference.md) — the clauses that hurt a small company, what to ask for in each, and the starting wording
+- [`scripts/contract_check.py`](scripts/contract_check.py) — blanks, cross-references, numbering, defined terms, words-and-figures, dates, notice deadlines
+- [`examples/saas-agreement.md`](examples/saas-agreement.md) — worked example: a supplier's SaaS agreement with seven mechanical faults and an uncapped indemnity
+
+## Quality bar
+
+- **Every mechanical finding has a clause number** and comes from the check.
+- **The verdict leads,** with the three things that matter most, in plain words.
+- **Every commercial problem says why it hurts this founder** and gives the wording to ask for.
+- **Every notice deadline is a date,** when the term's end is known.
+- **At most two lawyer lines,** each naming the clause and why.
+- **No script, file or skill talk in the reply,** and their document is never overwritten.
+
+## When to use this skill
+
+- ✅ A customer's or vendor's agreement arrived and the founder is about to sign it
+- ✅ The founder's own template is going out and should be clean
+- ✅ An auto-renewing contract and the question "when do we have to cancel by?"
+- ✅ An NDA, consulting or contractor agreement before the first project starts
+
+## When NOT to use this skill
+
+- ❌ Drafting an agreement from nothing: start from a reviewed template, then check it here
+- ❌ A dispute already under way, or a letter from someone's lawyer: get a lawyer
+- ❌ Employment contracts, share purchase agreements and anything signed with a personal guarantee: these need a lawyer from the start
+- ❌ What a SAFE or term sheet does to ownership: model it with a cap table
+
+## Anti-patterns to avoid
+
+- ❌ **"Section 14.3 looks fine" without checking it exists.** Renumbering after a negotiation leaves dangling references; the check finds them.
+- ❌ **Reading from the wrong side.** An uncapped indemnity is a gift if the founder receives it and a threat if they give it.
+- ❌ **A list of thirty issues with no order.** The founder has an hour; lead with what stops the signature.
+- ❌ **"Consider negotiating the liability clause."** Give the words to ask for.
+- ❌ **A disclaimer paragraph at the top.** Say what a lawyer should look at, specifically, at the end.
+- ❌ **Missing the renewal window.** "60 days before the end of the term" is a date; work it out.
+- ❌ **Overwriting their file with a marked-up version.** They lose the one they were sent.

package/packs/startup-legal/skills/contract-check/evals/eval_queries.json

@@ -0,0 +1,30 @@
+[
+  {
+    "query": "Review this contract before I sign it",
+    "should_trigger": true
+  },
+  {
+    "query": "Check this NDA the customer sent us",
+    "should_trigger": true
+  },
+  {
+    "query": "What should I push back on in this MSA?",
+    "should_trigger": true
+  },
+  {
+    "query": "Is our consulting agreement ready to send?",
+    "should_trigger": true
+  },
+  {
+    "query": "Compare these three vendors' pricing in a table",
+    "should_trigger": false
+  },
+  {
+    "query": "Fill in this security questionnaire from our policies",
+    "should_trigger": false
+  },
+  {
+    "query": "Write the DPIA for our new analytics feature",
+    "should_trigger": false
+  }
+]

package/packs/startup-legal/skills/contract-check/evals/evals.json

@@ -0,0 +1,46 @@
+{
+  "skill_name": "contract-check",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Northgate sent their SaaS agreement, it's saas-agreement.md. We're Brightloop, the customer. The first year ends 1 July 2027. Anything I should push back on before I sign?",
+      "assertions": [
+        "Opens with a verdict and the few problems that matter most, not with a disclaimer",
+        "Flags the [●] fee in 3.1, the missing Exhibit C in 2.1, and the reference to Section 14.3 in 8.2, which doesn't exist",
+        "Flags 'thirty (60) days' in 3.2 and the impossible date 31 June 2026",
+        "Reads from the customer's side and flags the one-way indemnity in 6.3 and the one-sided liability cap in 6.1, each with wording to ask for",
+        "Gives the renewal notice deadline as 2 May 2027",
+        "Notes 'the Client' is used where the agreement defines 'the Customer'",
+        "Does not mention a script or the skill's name, and does not invent clauses that aren't in the agreement"
+      ]
+    },
+    {
+      "id": 2,
+      "held_out": "2026-11-06",
+      "prompt": "our first contractor sent this over, can you check consulting-agreement.md before I sign? anything I should push back on",
+      "assertions": [
+        "It works out that the founder is the client, Halyard Robotics ('Company'), hiring the consultant, and reviews the terms from Halyard's side",
+        "It flags the date that doesn't exist (February 30, 2027) in the opening paragraph and the fee in clause 2.1 where the words (Twelve Thousand Dollars) disagree with the figures ($21,000), and says the right amount has to be confirmed before signing",
+        "It flags the blank expense cap in clause 2.3, the numbering that jumps from section 6 to section 8 (there is no section 7), and the reference in clause 11.2 to an Exhibit C that isn't attached",
+        "It says that under clauses 6.1–6.3 Halyard will not own the robot-housing designs it is paying for (it gets only a non-exclusive internal licence, and the consultant can license the same designs to others), and asks for the IP to be assigned to Halyard on payment",
+        "It flags the one-sided, uncapped indemnity in clauses 10.1 and 9.3: Halyard covers the consultant even for claims that the consultant's own designs infringe someone else's IP. It asks for the indemnity to be mutual, or for the consultant to give the IP-infringement indemnity",
+        "It flags the termination imbalance in clauses 3.2–3.4: the consultant can walk away on 5 days' notice, Halyard can only end the agreement for an uncured breach, and Halyard still owes the full fee on any termination. It asks for a right to terminate for convenience that pays only for work done",
+        "It does not invent clauses, auto-renewal terms, notice deadlines, amounts or parties that are not in the agreement"
+      ]
+    },
+    {
+      "id": 3,
+      "held_out": "2026-11-06",
+      "prompt": "I'm the founder of Brightmoor Analytics, a 6-person UK company. We make Brightmoor Insight, planning-analytics software for local councils. Calder Systems want to resell it to councils, and their lawyer sent over reseller-agreement.md. We're the Supplier. Is it ready to sign, and what should I push back on before our call on Thursday? Also, if the first year goes badly, what's the last date I can tell them we don't want it to roll over?",
+      "assertions": [
+        "It flags that 'Territory' is defined twice and the two definitions conflict (England and Wales in clause 1.6; the United Kingdom and the Republic of Ireland in clause 3.1), and says which one widens the exclusivity",
+        "It flags that 'Net Revenue', the basis for Brightmoor's 60% share in clause 5.1, is never defined; that clause 6.1 refers to a Schedule 3 that doesn't exist; that the onboarding fee in clause 5.3 says fifteen thousand pounds in words but GBP 50,000 in figures; and that Calder's registered office is left blank, even though clause 13.2 sends notices there",
+        "It gives the non-renewal deadline as 1 January 2028 (90 days before the Initial Term ends on 31 March 2028; 31 December 2027 is also acceptable if it counts clear days). It points out that 1 January 2028 is a Saturday and a bank holiday and that notice must go by recorded delivery, so it should be sent well before then. It also warns that a missed deadline locks Brightmoor in for 24 more months, to 31 March 2030",
+        "It flags the exclusivity in clauses 2.1–2.4: Brightmoor is barred from selling to any public-sector body in the Territory, which is its whole market, while Calder has no minimum sales commitment and can appoint sub-resellers. It asks for minimum targets, the right to end exclusivity if they're missed, a narrower territory, or a carve-out for direct sales",
+        "It flags the liability imbalance: Brightmoor's liability is unlimited (clause 11.3) and it gives a broad indemnity for anything 'in connection with' the agreement (clause 10.1), while Calder's liability is capped at GBP 10,000 (clause 11.2). It asks for a mutual cap, for example tied to fees paid, and for the indemnity to be narrowed to IP-infringement claims",
+        "It flags the pay-when-paid terms in clause 5.2: Brightmoor is paid only 90 days after the end of the month in which the council pays Calder, and not at all if the council doesn't pay, so Brightmoor carries Calder's credit risk. It asks for fixed payment terms counted from Calder's invoice to the council",
+        "It does not invent clauses, schedules, prices, dates or parties that are not in the agreement, and it does not present its review as legal advice that replaces a solicitor"
+      ]
+    }
+  ]
+}

package/packs/startup-legal/skills/contract-check/evals/files/1/saas-agreement.md

@@ -0,0 +1,68 @@
+# Software Services Agreement
+
+This Software Services Agreement (the "Agreement") is made on 31 June 2026 between Northgate Analytics Ltd, a company registered in England (the "Supplier"), and Brightloop Labs Inc. (the "Customer").
+
+## 1. Definitions
+
+1.1 "Services" means the hosted analytics platform described in Exhibit A.
+
+1.2 "Confidential Information" means any information disclosed by one party to the other that is marked confidential or would reasonably be understood to be confidential.
+
+1.3 "Customer Data" means data uploaded to the Services by the Customer.
+
+1.4 "Fees" means the fees set out in Exhibit B.
+
+## 2. Services
+
+2.1 The Supplier shall provide the Services to the Customer from the Effective Date in accordance with the service levels in Exhibit C.
+
+2.2 The Supplier may update the Services at any time, provided it does not materially reduce their functionality.
+
+## 3. Fees and Payment
+
+3.1 The Customer shall pay the Fees of [●] per month, invoiced monthly in advance.
+
+3.2 Invoices are payable within thirty (60) days of the invoice date.
+
+3.3 Late payments bear interest at four percent (4%) per month.
+
+## 4. Term and Renewal
+
+4.1 This Agreement starts on the Effective Date and continues for twelve (12) months (the "Initial Term").
+
+4.2 It renews automatically for successive twelve (12) month periods unless either party gives at least sixty (60) days' written notice before the end of the then-current term.
+
+## 5. Confidentiality
+
+5.1 Each party shall keep the other's confidential information secret and use it only to perform this Agreement.
+
+5.2 "Confidential Information" includes the terms of this Agreement.
+
+## 6. Liability
+
+6.1 The Supplier's total liability under this Agreement is limited to the Fees paid in the three (3) months before the claim.
+
+6.2 Nothing in Section 6.1 limits liability for death or personal injury caused by negligence.
+
+6.3 The Client shall indemnify the Supplier against any claim arising from the Client's use of the Services.
+
+## 8. Termination
+
+8.1 Either party may terminate this Agreement on ninety (90) days' written notice.
+
+8.2 On termination, Section 5 and Section 14.3 survive.
+
+## 9. General
+
+9.1 This Agreement is governed by the laws of England and Wales.
+
+Signed: ____________________
+
+# Exhibit A — Services
+
+1. Dashboards
+2. Data connectors
+
+# Exhibit B — Fees
+
+1. Platform fee: $2,000 per month