skilldrop-cli 1.8.0 → 1.10.0

package/packs/startup-legal/skills/contract-check/scripts/contract_check.py

@@ -0,0 +1,413 @@
+#!/usr/bin/env python3
+"""Check an agreement for the mechanical faults that slip past a read-through. Stdlib only.
+
+Reads a contract as Markdown, plain text or Word (.docx) and reports, each with where it is:
+  - blanks left in: [●], [•], [___], ____, [DATE], [insert …], TBD
+  - cross-references to a clause, section, schedule, exhibit, annex or appendix that doesn't exist
+  - clause numbering that skips or repeats
+  - a defined term defined twice, defined and never used, or used in lower case once defined
+  - a role or object used as if defined (Customer, Services, Confidential Information …) but never defined
+  - an amount or period in words that disagrees with its figure: "thirty (60) days", "ten thousand ($1,000)"
+  - a date that doesn't exist (31 June, 29 February in a non-leap year)
+and lists every notice period, so deadlines can be worked out.
+
+It checks the document's consistency, not whether its terms are fair or lawful.
+
+Usage:
+  python3 contract_check.py agreement.docx [--json]
+Exit codes: 0 no failures, 1 a failure, 2 the file can't be read.
+"""
+import argparse
+import json
+import re
+import sys
+import zipfile
+from xml.etree import ElementTree
+
+W = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
+
+
+def read_text(path):
+    if path.lower().endswith(".docx"):
+        with zipfile.ZipFile(path) as z:
+            root = ElementTree.fromstring(z.read("word/document.xml"))
+        lines = []
+        for p in root.iter(W + "p"):
+            text = "".join(t.text or "" for t in p.iter(W + "t"))
+            lines.append(text)
+        return lines
+    with open(path, encoding="utf-8-sig") as f:
+        return f.read().splitlines()
+
+
+# ---------- numbering and cross-references ----------
+
+MULTI = re.compile(r"^\s*(?:#+\s*)?(?:\*\*)?\s*(?:(?:clause|section|article)\s+)?(\d+(?:\.\d+){1,3})\.?(?=\s|\*\*|$)", re.I)
+SINGLE = re.compile(r"^\s*(#+\s*)?(\*\*)?\s*((?:clause|section|article)\s+)?(\d{1,3})\.?(?=\s|\*\*|$)(.*)$", re.I)
+APPENDIX_HEAD = re.compile(r"^\s*(?:#+\s*)?(?:\*\*)?\s*(schedule|exhibit|annex|appendix|annexure)\s+([A-Z0-9]{1,3})\b", re.I)
+REF = re.compile(r"\b(clauses?|sections?|articles?)\s+(\d+(?:\.\d+){0,3})((?:\s*(?:,|and|or|to|-|–)\s*\d+(?:\.\d+){0,3})*)", re.I)
+APPENDIX_REF = re.compile(r"\b(schedule|exhibit|annex|appendix|annexure)\s+([A-Z0-9]{1,3})\b", re.I)
+
+
+def clause_number(line):
+    """The clause number a line starts, or None. "7.2 …" anywhere counts; a bare "7." counts only
+    as a heading (Markdown #, bold, "Clause 7", or a short title line), so a numbered list inside
+    a clause isn't read as clauses."""
+    m = MULTI.match(line)
+    if m:
+        return m.group(1)
+    m = SINGLE.match(line)
+    if not m:
+        return None
+    hashes, bold, word, n, rest = m.groups()
+    rest = rest.strip().strip("*").strip()
+    if hashes or bold or word:
+        return n
+    if rest and len(rest) <= 60 and not rest.endswith((".", ";", ",")) and rest[:1].isupper():
+        return n
+    return None
+
+
+def appendix_at(line):
+    a = APPENDIX_HEAD.match(line)
+    if a and len(line.strip()) < 120:
+        return (a.group(1).lower().replace("annexure", "annex"), a.group(2).upper())
+    return None
+
+
+def scan(lines):
+    """Clause numbers in the main body, appendices present, and each numbered line with its scope."""
+    nums, apps, numbered = {}, {}, []
+    scope = "body"
+    for i, line in enumerate(lines, 1):
+        key = appendix_at(line)
+        if key:
+            apps.setdefault(key, i)
+            scope = key
+            continue
+        n = clause_number(line)
+        if n:
+            numbered.append((scope, n, i))
+            if scope == "body":
+                nums.setdefault(n, i)
+    return nums, apps, numbered
+
+
+def numbering_faults(numbered):
+    out = []
+    seen = {}
+    last = {}
+    for scope, n, i in numbered:
+        if (scope, n) in seen:
+            out.append(("FAIL", i, f"clause {n} is numbered twice (also line {seen[(scope, n)]})"))
+            continue
+        seen[(scope, n)] = i
+        parts = [int(x) for x in n.split(".")]
+        parent = (scope,) + tuple(parts[:-1])
+        prev = last.get(parent)
+        if prev is not None and parts[-1] > prev + 1:
+            want = ".".join(map(str, parts[:-1] + [prev + 1]))
+            out.append(("WARN", i, f"clause numbering jumps to {n}; {want} is missing"))
+        last[parent] = parts[-1]
+        for k in [k for k in last if len(k) > len(parent) and k[:len(parent)] == parent and k[len(parent)] != parts[-1]]:
+            del last[k]
+    return out
+
+
+def ref_faults(lines, nums, apps):
+    out = []
+    tops = {n.split(".")[0] for n in nums}
+    if not nums:
+        return [("WARN", 0, "no numbered clauses found, so cross-references were not checked")]
+    for i, line in enumerate(lines, 1):
+        body = MULTI.sub("", line, count=1) if MULTI.match(line) else line
+        for m in REF.finditer(body):
+            targets = [m.group(2)] + re.findall(r"\d+(?:\.\d+){0,3}", m.group(3) or "")
+            for t in targets:
+                if t in nums or (("." not in t) and t in tops):
+                    continue
+                out.append(("FAIL", i, f"refers to {m.group(1).rstrip('s').lower()} {t}, which doesn't exist"))
+        for m in APPENDIX_REF.finditer(line):
+            key = (m.group(1).lower().replace("annexure", "annex"), m.group(2).upper())
+            if appendix_at(line) and m.start() < 12:
+                continue
+            if key not in apps and not re.match(r"^(this|the|each|any|a)$", m.group(2), re.I):
+                out.append(("FAIL", i, f"refers to {key[0].title()} {key[1]}, which isn't in the document"))
+    return dedupe(out)
+
+
+# ---------- blanks ----------
+
+BLANKS = [
+    (re.compile(r"\[\s*[●•]+\s*\]|[●•]{1,}"), "a [●] placeholder"),
+    (re.compile(r"\[\s*_+\s*\]|_{4,}"), "a blank line to fill in"),
+    (re.compile(r"\[(?:insert|enter|add|date|name|address|amount|company|party|tbc|tbd|xx+)[^\]]{0,40}\]", re.I), "a bracketed placeholder"),
+    (re.compile(r"\bTB[CD]\b"), "TBD/TBC"),
+    (re.compile(r"\bX{2,}\b"), "an XX placeholder"),
+]
+
+
+def blank_faults(lines):
+    out = []
+    for i, line in enumerate(lines, 1):
+        for rx, what in BLANKS:
+            m = rx.search(line)
+            if m:
+                out.append(("FAIL", i, f"{what} is still in: “{snippet(line, m.start())}”"))
+                break
+    return out
+
+
+# ---------- defined terms ----------
+
+DEF_PATTERNS = [
+    re.compile(r"\(\s*(?:the\s+|each\s+a\s+|together\s+the\s+|hereinafter\s+(?:the\s+)?)?[\"“]([A-Z][A-Za-z0-9&'\- ]{1,60}?)[\"”]\s*\)"),
+    re.compile(r"[\"“]([A-Z][A-Za-z0-9&'\- ]{1,60}?)[\"”]\s+(?:means|shall mean|has the meaning|includes|refers to)\b"),
+    re.compile(r"\*\*[\"“]?([A-Z][A-Za-z0-9&'\- ]{1,60}?)[\"”]?\*\*\s+(?:means|shall mean|has the meaning)\b"),
+]
+
+COMMON = ["Agreement", "Customer", "Client", "Company", "Supplier", "Vendor", "Provider", "Service Provider",
+          "Licensee", "Licensor", "Contractor", "Consultant", "Services", "Deliverables", "Software", "Fees",
+          "Effective Date", "Term", "Territory", "Confidential Information", "Intellectual Property",
+          "Intellectual Property Rights", "Affiliate", "Personal Data", "Products", "Order Form",
+          "Statement of Work", "Disclosing Party", "Receiving Party", "Purpose", "Business Day",
+          "Commencement Date", "Investor", "Founder", "Employee", "Platform", "Subscription Term",
+          "Documentation", "Customer Data", "Work Product", "Background IP", "Licensed Materials"]
+
+
+def definitions(lines):
+    defs = {}
+    for i, line in enumerate(lines, 1):
+        for rx in DEF_PATTERNS:
+            for m in rx.finditer(line):
+                term = m.group(1).strip()
+                if len(term) < 2 or term.lower() in ("the", "a", "an"):
+                    continue
+                defs.setdefault(term, []).append(i)
+    return defs
+
+
+def term_faults(lines, defs):
+    out = []
+    text = "\n".join(lines)
+    for term, where in defs.items():
+        places = sorted(set(where))
+        if len(places) > 1:
+            out.append(("FAIL", places[1], f"“{term}” is defined more than once (lines {', '.join(map(str, places))})"))
+        uses = len(re.findall(r"(?<![A-Za-z])" + re.escape(term) + r"(?![A-Za-z])", text))
+        if uses <= len(where):
+            out.append(("WARN", places[0], f"“{term}” is defined but never used"))
+        lower = [n for n, l in enumerate(lines, 1) if n not in places and
+                 re.search(r"(?<![A-Za-z])" + re.escape(term.lower()) + r"(?![A-Za-z])", l) and len(term.split()) > 1]
+        if lower:
+            out.append(("WARN", lower[0], f"“{term.lower()}” appears in lower case although “{term}” is a "
+                                           f"defined term (lines {', '.join(map(str, lower[:5]))})"))
+    defined_lower = {t.lower() for t in defs}
+    for term in COMMON:
+        if term.lower() in defined_lower:
+            continue
+        rx = re.compile(r"(?<=[a-z,;] )(?:the )?" + re.escape(term) + r"(?![A-Za-z])")
+        hits = [(n, len(rx.findall(l))) for n, l in enumerate(lines, 1) if rx.search(l)]
+        count = sum(c for _, c in hits)
+        if count >= 2:
+            out.append(("WARN", hits[0][0], f"“{term}” is used as a defined term (capitalised, {count} times) but "
+                                            "never defined"))
+    return out
+
+
+# ---------- amounts in words and figures ----------
+
+UNITS = {w: i for i, w in enumerate("zero one two three four five six seven eight nine ten eleven twelve thirteen "
+                                     "fourteen fifteen sixteen seventeen eighteen nineteen".split())}
+TENS = {w: 10 * i for i, w in enumerate("_ _ twenty thirty forty fifty sixty seventy eighty ninety".split()) if w != "_"}
+SCALES = {"hundred": 100, "thousand": 1000, "lakh": 100000, "lakhs": 100000, "million": 10 ** 6,
+          "crore": 10 ** 7, "crores": 10 ** 7, "billion": 10 ** 9}
+WORD = r"(?:zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|" \
+       r"seventeen|eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|thousand|lakhs?|" \
+       r"million|crores?|billion|and|point)"
+WORDS_FIG = re.compile(r"\b((?:" + WORD + r")(?:[\s-]+" + WORD + r")*)\b(?:\s+[A-Za-z]+){0,3}?\s*\(\s*([$€£₹]?\s?[\d,]+(?:\.\d+)?)\s*\)", re.I)
+
+
+def words_to_number(words):
+    total, current = 0, 0
+    toks = [t for t in re.split(r"[\s-]+", words.lower()) if t and t != "and"]
+    if not toks or "point" in toks:
+        return None
+    for t in toks:
+        if t in UNITS:
+            current += UNITS[t]
+        elif t in TENS:
+            current += TENS[t]
+        elif t == "hundred":
+            current = (current or 1) * 100
+        elif t in SCALES:
+            total += (current or 1) * SCALES[t]
+            current = 0
+        else:
+            return None
+    return total + current
+
+
+def amount_faults(lines):
+    out = []
+    for i, line in enumerate(lines, 1):
+        for m in WORDS_FIG.finditer(line):
+            words = m.group(1)
+            if words.strip().lower() in ("and", "point", "one"):
+                if words.strip().lower() != "one":
+                    continue
+            val = words_to_number(words)
+            fig = float(re.sub(r"[^\d.]", "", m.group(2)) or "nan")
+            if val is None or fig != fig:
+                continue
+            if abs(val - fig) > 1e-9:
+                out.append(("FAIL", i, f"“{m.group(0).strip()}”: the words say {val:,} and the figure says {fig:,.0f}"))
+    return out
+
+
+# ---------- dates and notice periods ----------
+
+MONTHS = {m: i for i, m in enumerate(["january", "february", "march", "april", "may", "june", "july", "august",
+                                      "september", "october", "november", "december"], 1)}
+DATE1 = re.compile(r"\b(\d{1,2})(?:st|nd|rd|th)?\s+(?:day\s+of\s+)?(" + "|".join(MONTHS) + r"),?\s+(\d{4})\b", re.I)
+DATE2 = re.compile(r"\b(" + "|".join(MONTHS) + r")\s+(\d{1,2})(?:st|nd|rd|th)?,?\s+(\d{4})\b", re.I)
+NOTICE = re.compile(r"\(?(\d{1,3})\)?\s+(business\s+days?|calendar\s+days?|days?|weeks?|months?)[’']?\s*"
+                    r"(?:(?:prior\s+)?(?:written\s+)?notice|(?:prior\s+to|before)\s+(?:the\s+)?(?:end|expiry|expiration|renewal))",
+                    re.I)
+
+
+def date_faults(lines):
+    import calendar
+    out = []
+    for i, line in enumerate(lines, 1):
+        for m in list(DATE1.finditer(line)) + list(DATE2.finditer(line)):
+            if m.re is DATE1:
+                d, mon, y = int(m.group(1)), MONTHS[m.group(2).lower()], int(m.group(3))
+            else:
+                mon, d, y = MONTHS[m.group(1).lower()], int(m.group(2)), int(m.group(3))
+            if not 1 <= d <= calendar.monthrange(y, mon)[1]:
+                out.append(("FAIL", i, f"“{m.group(0)}” is not a real date"))
+    return out
+
+
+def notices(lines, term_end=None):
+    found = []
+    for i, line in enumerate(lines, 1):
+        for m in NOTICE.finditer(line):
+            n = {"line": i, "period": f"{m.group(1)} {m.group(2).lower()}", "text": snippet(line, m.start(), 90)}
+            before_end = re.search(r"before|prior to|renew|expir|end of", line[m.start():], re.I)
+            if term_end and before_end:
+                n["notice_by"] = notice_by(term_end, int(m.group(1)), m.group(2).lower()).isoformat()
+            found.append(n)
+    return found
+
+
+def notice_by(end, n, unit):
+    """The last day notice can be given so that n units still remain before `end`."""
+    import calendar
+    import datetime as dt
+    if unit.startswith("business"):
+        d, left = end, n
+        while left:
+            d -= dt.timedelta(days=1)
+            if d.weekday() < 5:
+                left -= 1
+        return d
+    if unit.startswith("week"):
+        return end - dt.timedelta(weeks=n)
+    if unit.startswith("month"):
+        y, mth = divmod(end.year * 12 + end.month - 1 - n, 12)
+        return end.replace(year=y, month=mth + 1, day=min(end.day, calendar.monthrange(y, mth + 1)[1]))
+    return end - dt.timedelta(days=n)
+
+
+# ---------- output ----------
+
+def snippet(line, at, width=60):
+    start = max(0, at - 20)
+    s = line[start:start + width].strip()
+    return ("…" if start else "") + s + ("…" if start + width < len(line) else "")
+
+
+def dedupe(items):
+    seen, out = set(), []
+    for it in items:
+        if it not in seen:
+            seen.add(it)
+            out.append(it)
+    return out
+
+
+def check(lines, term_end=None):
+    nums, apps, numbered = scan(lines)
+    defs = definitions(lines)
+    findings = (blank_faults(lines) + ref_faults(lines, nums, apps) + numbering_faults(numbered) +
+                term_faults(lines, defs) + amount_faults(lines) + date_faults(lines))
+    findings = dedupe(findings)
+    findings.sort(key=lambda f: (f[0] != "FAIL", f[1]))
+    return {"findings": findings, "clauses": len(nums), "appendices": sorted(f"{k[0].title()} {k[1]}" for k in apps),
+            "defined_terms": sorted(defs), "notices": notices(lines, term_end)}
+
+
+def clause_at(lines, n):
+    """The nearest numbered clause at or above line n, for a reader who has the document open."""
+    for i in range(min(n, len(lines)), 0, -1):
+        if appendix_at(lines[i - 1]):
+            return None
+        c = clause_number(lines[i - 1])
+        if c:
+            return c
+    return None
+
+
+def report(path, lines, r):
+    L = [f"# Contract check: {path}", "",
+         f"{r['clauses']} numbered clauses, {len(r['defined_terms'])} defined terms, "
+         f"{len(r['appendices'])} schedules or exhibits ({', '.join(r['appendices']) or 'none'}).", ""]
+    if not any(f[0] == "FAIL" for f in r["findings"]):
+        L.append("PASS no blanks, broken cross-references, repeated clause numbers, doubly defined terms, "
+                 "mismatched amounts or impossible dates.")
+    for level, line, msg in r["findings"]:
+        where = f"line {line}" if line else "document"
+        c = clause_at(lines, line) if line else None
+        if c:
+            where += f", clause {c}"
+        L.append(f"{level} [{where}] {msg}")
+    if r["notices"]:
+        L += ["", "Notice periods:"]
+        for n in r["notices"]:
+            c = clause_at(lines, n["line"])
+            by = f" — give notice by {n['notice_by']}" if n.get("notice_by") else ""
+            L.append(f"- {n['period']} (line {n['line']}{', clause ' + c if c else ''}){by}: {n['text']}")
+    return "\n".join(L) + "\n"
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="Check an agreement's mechanics.")
+    ap.add_argument("document")
+    ap.add_argument("--json", action="store_true")
+    ap.add_argument("--term-end", help="YYYY-MM-DD the current term ends, to date each notice deadline")
+    args = ap.parse_args(argv)
+    term_end = None
+    if args.term_end:
+        import datetime as dt
+        try:
+            term_end = dt.date.fromisoformat(args.term_end)
+        except ValueError:
+            print("FAIL --term-end must be a date as YYYY-MM-DD")
+            return 2
+    try:
+        lines = read_text(args.document)
+    except (OSError, UnicodeDecodeError, zipfile.BadZipFile, KeyError, ElementTree.ParseError) as e:
+        print(f"FAIL cannot read {args.document}: {e}")
+        return 2
+    r = check(lines, term_end)
+    if args.json:
+        print(json.dumps(r, indent=2, ensure_ascii=False))
+    else:
+        print(report(args.document, lines, r), end="")
+    return 1 if any(f[0] == "FAIL" for f in r["findings"]) else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,119 @@
+---
+name: lease-check
+description: Check a commercial lease before a startup signs it for its first office, studio or lab — a script turns the lease's terms into every date and sum the tenant must plan around (rent year by year through stepped rents, fixed and index-linked reviews with caps and collars, rent-free months, what the company is committed to pay up to each break and to the end, and each break, renewal and notice deadline as a date), then flags terms that can't all be true and deadlines already passed — and reads the lease for the clauses that hurt a small tenant. Use when a founder says "review this office lease", "what's our break clause notice date", "how much are we committing to on this lease", "check this lease before I sign", "when can we get out of this lease", or "what does the rent review do".
+---
+
+# lease-check
+
+A first office lease is often the biggest commitment a young company signs, and founders sign
+it on the headline rent. What hurts is in the detail. The break clause needs six months'
+notice and any unpaid sum voids it. The CPI review compounds three years at once. The rent-free
+months are forfeited if the break is used. Repair obligations hand the tenant the roof. A
+script turns the lease's terms into the numbers: every deadline as a date, the rent each year,
+and what the company has committed to pay up to each exit. The agent reads the lease from the
+tenant's side.
+
+## How to respond
+
+**These rules come before the steps and outrank them:**
+
+- **Lead with the commitment and the exits, in a founder's words.** ✅ *"Signing commits you
+  to £113,400 up to the break in January 2030. To use the break you must give notice by 1 July
+  2029 and have paid everything, down to the last service-charge invoice, or the break fails
+  and you're in to 2031 for another £90,590."* Never mention a script, a JSON file, this
+  skill's name, a path inside its folder or a temporary path, and never call your work "the
+  check" or "a tool".
+- **Every date and sum comes from the computed terms,** with the clause behind it.
+- **Read for the tenant's side,** and give the wording to ask for on each problem, ready to
+  paste into an email to the agent or landlord.
+- **Say what the terms can't price:** an open-market review, a service charge with no cap,
+  dilapidations at the end. Name each one, and suggest the ask that bounds it.
+- **Name what is worth a lawyer's hour, and only that.** One or two lines: a personal
+  guarantee, full repairing terms on an old building, a break with conditions the landlord
+  won't soften, or a lease outside the protection of business-tenancy law where that applies.
+  Never refuse, never open with a disclaimer.
+- **Working files stay out of sight.** The terms you extract go in a private temporary folder
+  (`mktemp -d`) and are deleted before replying. Never overwrite their lease.
+
+1. **Read the lease or heads of terms** and extract: start date, term in months, starting
+   rent, how it's paid, rent-free months, stepped rents, each rent review (month, type, any
+   cap, collar, upward-only), service charge and any cap, deposit, each break (month, notice,
+   who can break, conditions, any penalty), renewal option, notice to leave. Write down the
+   clause for each.
+
+2. **Write the terms** in the shape of [`templates/terms.json`](templates/terms.json). An
+   index-linked review over several years takes `years` so the cap and collar compound the way
+   the lease says; check the lease's wording, which differs on this. When the lease names a
+   break by its day ("the last day of the third year" is 28 February; "the third anniversary"
+   is 1 March), give it as the break's `date`: the notice date follows from it.
+
+3. **Run it** on today's date, so passed deadlines are flagged.
+
+   ```bash
+   work=$(mktemp -d 2>/dev/null || mktemp -d ./.work.XXXXXX)   # a private folder for this run only
+   # Claude Code
+   python3 "${CLAUDE_SKILL_DIR}/scripts/lease_terms.py" "$work/terms.json" --as-of 2026-11-08
+   # Other IDEs (from the skill folder)
+   python3 scripts/lease_terms.py "$work/terms.json"
+   ```
+
+   Exit 0 means computed, 1 means a deadline has passed or the terms contradict each other (a
+   break after the end, a notice that runs back before the start, rent-free as long as the
+   term), and 2 means the input can't be read.
+
+4. **Read the lease for the tenant** against [`reference.md`](reference.md): break conditions,
+   repair and reinstatement, dilapidations, service charge, alienation (subletting, assignment,
+   sharing with a group company), use, alterations, guarantees and rent deposits, insurance,
+   and whether the rent-free survives a break. For each problem: clause, why it hurts, wording
+   to ask for. Mark severity: 🟥 don't sign as is, 🟧 push back, 🟨 worth asking.
+
+5. **Reply in this order:**
+   1. **The commitment and the exits:** what signing commits to up to each break and to the
+      end, and the notice date for each break.
+   2. **Fixes before signing,** most severe first, with wording to ask for.
+   3. **Deadlines to diarise,** each as a date with its clause.
+   4. **Rent by year,** and what can't be priced yet.
+   5. **What to have a lawyer look at,** one or two lines.
+
+**Non-interactive runs** (subagent, CI, headless): unsaid terms are left out and named as
+missing, never filled with a typical value. With no start date, term or rent, emit `BLOCKED:
+need the lease (or heads of terms) with its start date, length and rent`.
+
+## Useful references in this skill
+
+- [`reference.md`](reference.md) — the lease clauses that hurt a small tenant, and what to ask for in each
+- [`templates/terms.json`](templates/terms.json) — the input: a five-year lease with rent-free, a capped CPI review and a conditional break
+- [`scripts/lease_terms.py`](scripts/lease_terms.py) — rent by year through reviews, committed cost to each break and the end, deadlines, contradictions
+- [`examples/first-office.md`](examples/first-office.md) — worked example: heads of terms for a first office, and what the break really costs
+
+## Quality bar
+
+- **The committed cost to each break and to the end is a sum,** rent and service charge, after rent-free.
+- **Every deadline is a date with its clause,** and a passed one is said plainly.
+- **Index-linked reviews compound the way the lease says,** within its cap and collar, and upward-only is applied.
+- **What can't be priced is named,** with the ask that bounds it.
+- **Every problem has the wording to ask for.**
+- **The reply leads with the commitment and the exits,** with no mention of scripts or files.
+
+## When to use this skill
+
+- ✅ Heads of terms or a draft lease for a first office, studio, lab or shop
+- ✅ "When can we get out of this lease, and what does it cost to stay till then?"
+- ✅ A rent review letter, or a break date coming up
+- ✅ Comparing two buildings on what each really commits the company to
+
+## When NOT to use this skill
+
+- ❌ A coworking membership with monthly terms: read its notice period, no schedule needed
+- ❌ Residential tenancies
+- ❌ A dispute with a landlord, or a dilapidations claim already made: get a surveyor or a lawyer
+- ❌ Buying a property
+
+## Anti-patterns to avoid
+
+- ❌ **Quoting the headline rent as the cost.** Rent-free, reviews and service charge move it; give the committed sum.
+- ❌ **"The break is in year three."** The notice date is what matters, and it's six months earlier.
+- ❌ **Treating a conditional break as certain.** One unpaid invoice can void it.
+- ❌ **Compounding a three-year CPI review as one year,** or ignoring its cap.
+- ❌ **Missing that rent-free is clawed back** if the break is used, when the lease says so.
+- ❌ **"The calculation shows…"** The founder wants the sum and the date.

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

@@ -0,0 +1,30 @@
+[
+  {
+    "query": "Review this office lease before we sign",
+    "should_trigger": true
+  },
+  {
+    "query": "What's the notice date for our lease break clause?",
+    "should_trigger": true
+  },
+  {
+    "query": "How much are we committing to on this lease?",
+    "should_trigger": true
+  },
+  {
+    "query": "When can we get out of our office lease and what does it cost to stay?",
+    "should_trigger": true
+  },
+  {
+    "query": "Review this SaaS agreement before I sign it",
+    "should_trigger": false
+  },
+  {
+    "query": "Find us coworking spaces in Manchester",
+    "should_trigger": false
+  },
+  {
+    "query": "Should we rent or buy a flat?",
+    "should_trigger": false
+  }
+]

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

@@ -0,0 +1,45 @@
+{
+  "skill_name": "lease-check",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "We've been offered heads of terms for our first office (heads-of-terms.md). The agent wants an answer this week. What are we committing to, and when could we get out?",
+      "assertions": [
+        "Gives the committed cost to the break on 1 January 2030 as about £113,400 (rent after 3 months rent-free plus service charge) and to the end as about £203,990",
+        "Gives the break notice deadline as 1 July 2029",
+        "Warns that the break's conditions (all sums paid, vacant possession) can make it fail, and gives wording to narrow them",
+        "Flags the personal guarantee, the uncapped service charge and full repairing with no schedule of condition, with wording to ask for",
+        "Computes the year-3 review at the 4% cap compounded over three years (about £40,495) or explains the range",
+        "Does not mention a script or the skill's name, and does not invent lease terms not in the heads of terms"
+      ]
+    },
+    {
+      "id": 2,
+      "held_out": "2026-11-08",
+      "prompt": "check this lease before I sign - heads-of-terms.md. how much are we committing to and when's the break notice date?",
+      "assertions": [
+        "Notices that a 5-year term from 1 March 2027 ends on 29 February 2032 (2032 is a leap year), and flags the heads of terms' 'expiring on 1 March 2032' as inconsistent with the stated term",
+        "Rent year by year: year 1 GBP 12,000 (6 months rent-free, then 6 x 2,000), year 2 GBP 24,000, years 3, 4 and 5 GBP 26,400 each",
+        "Committed to the break (to 28 February 2030): rent 12,000 + 24,000 + 26,400 = GBP 62,400 plus service charge 3 x 3,600 = GBP 10,800, total GBP 73,200 (exclusive of VAT, service charge at the current budget), with the convention stated",
+        "Committed to the end of the term: rent 12,000 + 24,000 + 3 x 26,400 = GBP 115,200 plus service charge 5 x 3,600 = GBP 18,000, total GBP 133,200",
+        "Break notice must be served on or before 28 August 2029 (6 months before the 28 February 2030 break date), and the answer warns that the break fails if any sum is unpaid or vacant possession is not given",
+        "Flags at least two tenant-hostile terms: the director's personal guarantee for the whole term, the uncapped service charge, and full repairing with no schedule of condition",
+        "Does not invent a rent deposit, VAT rate, open-market rent review, or other terms not in the heads of terms"
+      ]
+    },
+    {
+      "id": 3,
+      "held_out": "2026-11-08",
+      "prompt": "We're Quokka Bio, a 9-person biotech, and this would be our first lab. Our landlord's agent sent heads-of-agreement.md and wants it signed off this week. Can you work out what we'd be committing to pay to the break and to the end of the term, give me every notice date we need in the calendar, and tell me which clauses I should push back on? Treat all money as ex GST, and use the outgoings estimate as flat for the whole term.",
+      "assertions": [
+        "Flags the conflict between '3 months rent-free from the commencement date' (rent would start 1 December 2027) and the stated rent commencement date of 1 November 2027 (only 2 months), says which it used and asks for it to be fixed",
+        "Gives the CPI reviews as a range using the collar and cap: from 1 September 2028 rent is A$97,920 (2%) to A$100,800 (5%); from 1 September 2029 A$99,878.40 (2% on 2%) to A$105,840 (5% on 5%); the minimum is what is committed",
+        "Committed to the 31 August 2029 break using the 3-month rent-free: rent 72,000 (9 months of year 1) + 97,920 = A$169,920 plus outgoings 2 x 14,400 = A$28,800, total A$198,720 at the 2% collar (A$201,600 at the 5% cap), plus a break fee of 3 months' rent of A$24,480 (A$25,200 at cap), so about A$223,200 to A$226,800 to exit at the break; accept figures recomputed consistently on the 2-month reading if the convention is stated",
+        "Committed to the end of the term (31 August 2030): rent 72,000 + 97,920 + 99,878.40 = A$269,798.40 plus outgoings 3 x 14,400 = A$43,200, total A$312,998.40 at the collar (A$321,840 at the cap)",
+        "Break notice must be given no later than 28 February 2029 (6 months before 31 August 2029; there is no 29 February in 2029); the option to renew can only be exercised between 28 February 2030 (accept 1 March 2030) and 31 May 2030",
+        "Flags as hostile to a small tenant at least: the break condition voided by any breach at notice or break date, the upward-only market review on renewal, the uncapped outgoings, and the make-good to base-building condition",
+        "Does not invent a CPI figure presented as fact, a guarantor, a fit-out contribution, or other terms not in the heads of agreement"
+      ]
+    }
+  ]
+}

package/packs/startup-legal/skills/lease-check/evals/files/1/heads-of-terms.md

@@ -0,0 +1,15 @@
+# Heads of terms — Unit 4, Foundry Yard, Example Town
+
+- Landlord: Foundry Yard Estates Ltd
+- Tenant: Brightloop Labs Ltd
+- Premises: Unit 4, first floor, 2,100 sq ft
+- Term: 5 years from 1 January 2027
+- Rent: £36,000 a year exclusive, payable quarterly in advance
+- Rent-free: first 3 months
+- Rent review: at the end of year 3, to CPI over the preceding three years, compounded, with a cap of 4% a year and a collar of 1% a year; upward only
+- Service charge: estimated £4,800 a year, no cap
+- Deposit: 6 months' rent
+- Tenant break: end of year 3, on 6 months' prior written notice, conditional on all sums due under the lease having been paid and vacant possession being given
+- Repair: full repairing; no schedule of condition
+- Alienation: no subletting or sharing
+- Personal guarantee: from one director for the first 3 years

package/packs/startup-legal/skills/lease-check/evals/files/2/heads-of-terms.md

@@ -0,0 +1,32 @@
+# Heads of Terms - Subject to Contract
+
+**Property:** Unit 4, Gorse Mill, Canal Street, Halbrook HB3 7QT (ground floor studio, approx. 1,850 sq ft)
+
+**Landlord:** Gorse Mill Estates Limited
+
+**Tenant:** Fernlight Studio Ltd
+
+**Guarantor:** Imogen Marsh (director), personal guarantee of all tenant obligations for the whole term
+
+**Term:** 5 years from and including 1 March 2027, expiring on 1 March 2032
+
+**Rent:**
+- Years 1 and 2 (1 March 2027 to 28 February 2029): GBP 24,000 per annum exclusive
+- Years 3 to 5 (1 March 2029 to end of term): fixed increase to GBP 26,400 per annum exclusive
+- Payable quarterly in advance on the usual quarter days
+
+**Rent-free:** The first 6 months of the term are rent-free. Service charge is payable from the start of the term and is not covered by the rent-free period.
+
+**Service charge:** Tenant to pay a fair proportion of the landlord's costs of the estate. Current budget GBP 3,600 per annum. No cap.
+
+**Repair:** Full repairing and insuring. Tenant to keep the premises in good and substantial repair and condition and yield up in that condition. No schedule of condition.
+
+**Tenant break:** Tenant may terminate the lease at the end of the third year of the term (28 February 2030) by giving the landlord not less than 6 months' prior written notice. The break is conditional on: (i) all rent and other sums due under the lease having been paid in full, and (ii) the tenant giving vacant possession on the break date.
+
+**Use:** Design studio and ancillary offices (Class E).
+
+**Alienation:** No assignment or subletting of part. Assignment of the whole with landlord's consent, not to be unreasonably withheld, subject to an authorised guarantee agreement.
+
+**Security of tenure:** The lease is to be contracted out of the security of tenure provisions of the Landlord and Tenant Act 1954.
+
+**Costs:** Each party to bear its own legal costs.