skilldrop-cli 1.9.0 → 1.11.0

package/packs/educator/skills/exam-paper-check/scripts/exam_check.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""Check an exam paper and its mark scheme for the faults students and moderators find. Stdlib only.
+
+Reads the paper (Markdown, plain text or .docx) and, optionally, its mark scheme and a spec
+(duration, objectives and their target weightings, which question parts assess which objective).
+Reports, each with the question it is in:
+  - part marks that don't add up to a question's stated total, and questions that don't add up
+    to the paper's stated total (an "answer either 5 or 6" choice counts once)
+  - question numbers that skip or repeat, and parts that skip ((a), (c)) or repeat
+  - a part with no marks shown
+  - a part the mark scheme doesn't cover, a scheme entry for a part that isn't in the paper,
+    and a scheme whose marks differ from the paper's
+  - the time per mark, and an objective that is never assessed or is far off its weighting
+It checks the paper's arithmetic and structure, not whether its questions are good.
+
+Usage:
+  python3 exam_check.py paper.md [--scheme scheme.md] [--spec spec.json] [--json]
+Exit codes: 0 no failures, 1 a failure, 2 a 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}"
+ROMAN = ["i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix", "x", "xi", "xii"]
+
+QUESTION = re.compile(r"^\s*(?:#+\s*)?(?:\*\*)?\s*(?:question|q)\s*\.?\s*(\d{1,3})\b[.):]?(?:\*\*)?\s*(.*)$", re.I)
+BARE_Q = re.compile(r"^\s*(?:\*\*(\d{1,3})[.)]?\*\*|(\d{1,3})[.)])\s+(.*)$")
+PLAIN_Q = re.compile(r"^\s*(\d{1,3})\s+([A-Za-z].*)$")
+COMBINED = re.compile(r"^\s*(?:\*\*)?(\d{1,3})\s*\(?([a-z])\)?(?:\s*\(?((?:x|ix|iv|v?i{0,3}))\))?(?:\*\*)?[\s.:)]+(.*)$", re.I)
+PART = re.compile(r"^\s*(?:\*\*)?\(?([a-z])\)(?:\*\*)?\s*(.*)$")
+SUBPART = re.compile(r"^\s*(?:\*\*)?\(((?:x|ix|iv|v?i{1,3}|v))\)(?:\*\*)?\s*(.*)$", re.I)
+MARK = re.compile(r"[\[(]\s*(\d{1,3})\s*(?:marks?|m)?\s*[\])]\s*\**\s*$", re.I)
+Q_TOTAL = re.compile(r"(?:total\s+for\s+question\s+(\d{1,3})\s*(?:is|=|:)?\s*(\d{1,3})\s*marks?"
+                     r"|question\s+(\d{1,3})\s+total\s*(?:is|=|:)?\s*(\d{1,3})"
+                     r"|\[\s*total\s*(?:for\s+question\s+(\d{1,3}))?\s*[:=]?\s*(\d{1,3})\s*(?:marks?)?\s*\])", re.I)
+PAPER_TOTAL = re.compile(r"(?:total\s+(?:for\s+(?:this\s+)?paper|marks?\s+(?:for\s+(?:this\s+)?paper|available)|marks?)"
+                         r"\s*(?:is|=|:)?\s*(\d{1,4})|(?:this\s+paper\s+is\s+worth|maximum\s+mark\s*(?:is|:)?)\s*(\d{1,4})"
+                         r"|(\d{1,4})\s+marks?\s+in\s+total|total\s+of\s+(\d{1,4})\s+marks?)", re.I)
+DURATION = re.compile(r"(?:time(?:\s+allowed)?|duration)\s*[:=]?\s*(?:(\d{1,2})\s*h(?:ours?|rs?)?\s*)?(?:(\d{1,3})\s*min(?:utes?|s)?)?", re.I)
+EITHER = re.compile(r"answer\s+either\s+question\s+(\d{1,3})\s+or\s+(?:question\s+)?(\d{1,3})", re.I)
+
+
+def read_text(path):
+    if path.lower().endswith(".docx"):
+        with zipfile.ZipFile(path) as z:
+            root = ElementTree.fromstring(z.read("word/document.xml"))
+        return ["".join(t.text or "" for t in p.iter(W + "t")) for p in root.iter(W + "p")]
+    with open(path, encoding="utf-8-sig") as f:
+        return f.read().splitlines()
+
+
+def parse(lines):
+    """Questions with their parts and marks, in document order, plus the stated totals."""
+    qs = []
+    q = part = None
+    stated, stated_line, duration, choices = None, None, None, []
+
+    def new_question(n, line):
+        nonlocal q, part
+        q = {"n": n, "line": line, "parts": [], "stated": None, "marks": None}
+        qs.append(q)
+        part = None
+
+    def new_part(label, line):
+        nonlocal part
+        part = {"label": label, "line": line, "marks": None}
+        q["parts"].append(part)
+
+    for i, raw in enumerate(lines, 1):
+        line = raw.strip()
+        if not line:
+            continue
+        totals = list(Q_TOTAL.finditer(line))
+        if totals:
+            for m in totals:
+                qn = m.group(1) or m.group(3) or m.group(5)
+                val = int(m.group(2) or m.group(4) or m.group(6))
+                target = next((x for x in reversed(qs) if str(x["n"]) == qn), None) if qn else q
+                if target is not None:
+                    target["stated"] = val
+            continue
+        pm = PAPER_TOTAL.search(line)
+        if pm and stated is None and not re.search(r"question\s+\d", line, re.I):
+            stated, stated_line = int(next(g for g in pm.groups() if g)), i
+            continue
+        dm = DURATION.search(line)
+        if dm and duration is None and (dm.group(1) or dm.group(2)):
+            duration = int(dm.group(1) or 0) * 60 + int(dm.group(2) or 0)
+        choices += [(int(e.group(1)), int(e.group(2))) for e in EITHER.finditer(line)]
+
+        rest, labelled = line, False
+        m, c, b = QUESTION.match(line), COMBINED.match(line), BARE_Q.match(line)
+        if not b:
+            pl = PLAIN_Q.match(line)    # "4 Level-marked…" in a scheme: only as the next question number
+            if pl and (q is None and pl.group(1) == "1" or q is not None and int(pl.group(1)) == q["n"] + 1):
+                b = re.match(r"^\s*()(\d{1,3})\s+(.*)$", line)
+        sub, pt = SUBPART.match(line), PART.match(line)
+        if m:
+            new_question(int(m.group(1)), i)
+            rest, labelled = m.group(2), True
+        elif c and c.group(2).lower() <= "j":
+            n = int(c.group(1))
+            if q is None or q["n"] != n:
+                new_question(n, i)
+            new_part(c.group(2).lower() + (f"({c.group(3).lower()})" if c.group(3) else ""), i)
+            rest, labelled = c.group(4), True
+        elif b and (q is None or b.group(1) or int(b.group(2)) == q["n"] + 1):   # a bold number is always a question
+            new_question(int(b.group(1) or b.group(2)), i)
+            rest, labelled = b.group(3), True
+        elif q is not None and sub and part is not None and not (
+                sub.group(1).lower() == "i" and part["label"] == "h"):   # (i) after (h) is the next part
+            new_part(f"{part['label'].split('(')[0]}({sub.group(1).lower()})", i)
+            rest, labelled = sub.group(2), True
+        elif q is not None and pt:
+            new_part(pt.group(1).lower(), i)
+            rest, labelled = pt.group(2), True
+            inner = SUBPART.match(rest)        # "(a) (i) Describe…" opens the part and its first subpart
+            if inner:
+                new_part(f"{part['label']}({inner.group(1).lower()})", i)
+                rest = inner.group(2)
+        mk = MARK.search(rest)
+        if mk and q is not None:
+            if part is not None:
+                if part["marks"] is None:
+                    part["marks"] = int(mk.group(1))
+            elif q["marks"] is None:
+                q["marks"] = int(mk.group(1))
+    return {"questions": qs, "stated_total": stated, "stated_line": stated_line,
+            "duration": duration, "choices": choices}
+
+
+def q_marks(q):
+    leaves = leaf_parts(q)
+    if leaves:
+        return sum(p["marks"] or 0 for p in leaves)
+    return q["marks"] or 0
+
+
+def leaf_parts(q):
+    """Parts that carry marks themselves: (a)(i) and (a)(ii), not (a) when it has subparts."""
+    labels = [p["label"] for p in q["parts"]]
+    return [p for p in q["parts"] if not any(o.startswith(p["label"] + "(") for o in labels)]
+
+
+def check(paper, scheme=None, spec=None):
+    fails, warns = [], []
+    qs = paper["questions"]
+    if not qs:
+        return {"fails": ["no numbered questions found"], "warns": [], "rows": [], "total": 0, "stated_total": None,
+                "duration": None, "pace": None, "coverage": {}}
+    seen = {}
+    for q in qs:
+        if q["n"] in seen:
+            fails.append(f"Question {q['n']} is numbered twice (lines {seen[q['n']]} and {q['line']})")
+        seen.setdefault(q["n"], q["line"])
+    nums = sorted(seen)
+    for a, b in zip(nums, nums[1:]):
+        if b != a + 1:
+            warns.append(f"question numbers jump from {a} to {b}")
+    if nums[0] != 1:
+        warns.append(f"the first question is numbered {nums[0]}")
+    rows = []
+    for q in qs:
+        letters, last_roman = [], {}
+        for p in q["parts"]:
+            base, _, sub = p["label"].partition("(")
+            if sub:
+                r = sub.rstrip(")")
+                prev = last_roman.get(base)
+                want = ROMAN[ROMAN.index(prev) + 1] if prev in ROMAN and ROMAN.index(prev) + 1 < len(ROMAN) else "i"
+                if r != want:
+                    warns.append(f"Question {q['n']}({base}): part ({r}) follows ({prev or '—'}); expected ({want})")
+                last_roman[base] = r
+            else:
+                if base in letters:
+                    fails.append(f"Question {q['n']}: part ({base}) appears twice")
+                elif letters and ord(base) != ord(letters[-1]) + 1:
+                    warns.append(f"Question {q['n']}: part ({base}) follows ({letters[-1]}); "
+                                 f"({chr(ord(letters[-1]) + 1)}) is missing")
+                elif not letters and base != "a":
+                    warns.append(f"Question {q['n']}: the first part is ({base})")
+                letters.append(base)
+        for p in leaf_parts(q):
+            if p["marks"] is None:
+                warns.append(f"Question {q['n']}({p['label']}) shows no marks")
+        if not q["parts"] and q["marks"] is None and q["stated"] is None:
+            warns.append(f"Question {q['n']} shows no marks")
+        total = q_marks(q) if (q["parts"] or q["marks"] is not None) else (q["stated"] or 0)
+        if q["stated"] is not None and (q["parts"] or q["marks"] is not None) and total != q["stated"]:
+            fails.append(f"Question {q['n']}: the parts add up to {total} but the question total says {q['stated']}")
+        rows.append({"question": q["n"], "marks": total, "stated": q["stated"],
+                     "parts": {p["label"]: p["marks"] for p in leaf_parts(q)}})
+    by_n = {r["question"]: r["marks"] for r in rows}
+    total = sum(by_n.values())
+    for a, b in paper["choices"]:
+        if a in by_n and b in by_n:
+            total -= min(by_n[a], by_n[b])
+            if by_n[a] != by_n[b]:
+                fails.append(f"Questions {a} and {b} are a choice but are worth {by_n[a]} and {by_n[b]} marks")
+    stated = paper["stated_total"] if paper["stated_total"] is not None else (spec or {}).get("total")
+    if stated is not None and total != stated:
+        fails.append(f"the questions add up to {total} marks but the paper says {stated}")
+    duration = paper["duration"] or (spec or {}).get("duration_minutes")
+    pace = duration / total if duration and total else None
+    if scheme is not None:
+        smap = {}
+        for q in scheme["questions"]:
+            leaves = leaf_parts(q)
+            if leaves:
+                for p in leaves:
+                    smap[f"{q['n']}{p['label']}"] = p["marks"]
+            else:
+                smap[str(q["n"])] = q["marks"]
+        pmap = {}
+        for q in qs:
+            leaves = leaf_parts(q)
+            if leaves:
+                for p in leaves:
+                    pmap[f"{q['n']}{p['label']}"] = p["marks"]
+            else:
+                pmap[str(q["n"])] = q["marks"] if q["marks"] is not None else q["stated"]
+        for k, v in pmap.items():
+            if k not in smap:
+                fails.append(f"the mark scheme has nothing for {pretty(k)}")
+            elif smap[k] is not None and v is not None and smap[k] != v:
+                fails.append(f"{pretty(k)} is worth {v} on the paper but {smap[k]} in the mark scheme")
+        for k in smap:
+            if k not in pmap:
+                fails.append(f"the mark scheme covers {pretty(k)}, which isn't on the paper")
+        if scheme.get("stated_total") is not None:
+            s_by_q = {}
+            for k, v in smap.items():
+                n = int(re.match(r"\d+", k).group(0))
+                s_by_q[n] = s_by_q.get(n, 0) + (v or 0)
+            s_total = sum(s_by_q.values())
+            for a, b in paper["choices"]:
+                if a in s_by_q and b in s_by_q:
+                    s_total -= min(s_by_q[a], s_by_q[b])
+            if s_total != scheme["stated_total"]:
+                fails.append(f"the mark scheme says it is out of {scheme['stated_total']} but its own marks add up to {s_total}")
+    coverage = {}
+    if spec and spec.get("assesses"):
+        targets = spec.get("objectives", {})
+        pmarks = {}
+        for q in qs:
+            leaves = leaf_parts(q)
+            for p in leaves or [{"label": "", "marks": q_marks(q)}]:
+                pmarks[f"{q['n']}{p['label']}"] = p["marks"] or 0
+        dropped = {str(b) for _, b in paper["choices"]}   # a choice counts once
+        for key, objs in spec["assesses"].items():
+            k = key.replace(" ", "").lower()
+            if re.match(r"\d+", k).group(0) in dropped:
+                continue
+            share = pmarks.get(k)
+            if share is None:
+                matches = {pk: v for pk, v in pmarks.items() if pk.startswith(k)}
+                share = sum(matches.values()) if matches else None
+            if share is None:
+                warns.append(f"the spec maps {key} to objectives but there is no {key} on the paper")
+                continue
+            objs = [objs] if isinstance(objs, str) else objs
+            for o in objs:
+                coverage[o] = coverage.get(o, 0) + share / len(objs)
+        for o, target in targets.items():
+            got = coverage.get(o, 0)
+            if got == 0:
+                fails.append(f"objective {o} is never assessed")
+            elif target and total and abs(got / total * 100 - target) > max(5, target * 0.25):
+                warns.append(f"objective {o} has {got / total * 100:.0f} % of the marks against a target of {target:g} %")
+    return {"fails": fails, "warns": warns, "rows": rows, "total": total, "stated_total": stated,
+            "duration": duration, "pace": pace, "coverage": coverage}
+
+
+def pretty(key):
+    m = re.match(r"(\d+)([a-z]?)(\(.*\))?", key)
+    n, a, r = m.groups()
+    return f"Question {n}" + (f"({a})" if a else "") + (r or "")
+
+
+def report(r):
+    L = ["# Exam paper check", "", "| Question | Marks | Stated total | Parts |", "|---|---:|---:|---|"]
+    for row in r["rows"]:
+        parts = ", ".join(f"({k.replace('(', ')(').rstrip(')')}) {v if v is not None else '?'}" for k, v in row["parts"].items())
+        L.append(f"| {row['question']} | {row['marks']} | {row['stated'] if row['stated'] is not None else ''} | {parts} |")
+    L.append(f"| **Paper** | **{r['total']}** | {r['stated_total'] if r['stated_total'] is not None else ''} | |")
+    if r["pace"]:
+        L += ["", f"Time: {r['duration']} minutes for {r['total']} marks, {r['pace']:.2f} minutes a mark."]
+    if r["coverage"]:
+        L += ["", "| Objective | Marks | Share |", "|---|---:|---:|"]
+        for o, v in sorted(r["coverage"].items()):
+            L.append(f"| {o} | {v:g} | {v / r['total'] * 100:.0f} % |")
+    L.append("")
+    if not r["fails"]:
+        L.append("PASS every total adds up, numbering runs in order, and the scheme matches the paper.")
+    L += [f"FAIL {f}" for f in r["fails"]] + [f"WARN {w}" for w in r["warns"]]
+    return "\n".join(L) + "\n"
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="Check an exam paper and its mark scheme.")
+    ap.add_argument("paper")
+    ap.add_argument("--scheme", help="the mark scheme (.md, .txt or .docx)")
+    ap.add_argument("--spec", help="spec.json: duration_minutes, total, objectives {name: target %%}, assesses {part: [objectives]}")
+    ap.add_argument("--json", action="store_true")
+    args = ap.parse_args(argv)
+    try:
+        paper = parse(read_text(args.paper))
+        scheme = parse(read_text(args.scheme)) if args.scheme else None
+        spec = None
+        if args.spec:
+            with open(args.spec, encoding="utf-8-sig") as f:
+                spec = json.load(f)
+            if not isinstance(spec, dict):
+                raise ValueError("spec.json must be an object")
+    except (OSError, ValueError, UnicodeDecodeError, zipfile.BadZipFile, KeyError, ElementTree.ParseError) as e:
+        print(f"FAIL cannot read input: {e}")
+        return 2
+    r = check(paper, scheme, spec)
+    print(json.dumps(r, indent=2) if args.json else report(r), end="" if not args.json else "\n")
+    return 1 if r["fails"] else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/packs/educator/skills/exam-paper-check/templates/spec.json

@@ -0,0 +1,11 @@
+{
+  "duration_minutes": 50,
+  "total": 50,
+  "objectives": {"AO1": 40, "AO2": 40, "AO3": 20},
+  "assesses": {
+    "1a": "AO1", "1b": "AO2", "1c": "AO1",
+    "2a(i)": "AO1", "2a(ii)": "AO2", "2a(iii)": "AO2", "2b": "AO3",
+    "3a": "AO1", "3b": "AO3", "3c": "AO2",
+    "4": ["AO1", "AO3"]
+  }
+}

package/packs/startup-legal/pack.json

@@ -1,5 +1,5 @@
 {
-  "description": "Legal groundwork for a startup that can't yet pay a lawyer for everything: an agreement checked before you sign it (blanks, broken cross-references, mismatched amounts, the renewal date, and the clauses that hurt a small company, with wording to ask for), and your cap table modelled through SAFEs, notes and a priced round. Each says what is worth a lawyer's hour.",
+  "description": "Legal groundwork for a startup that can't yet pay a lawyer for everything: an agreement checked before you sign it (blanks, broken cross-references, mismatched amounts, the renewal date, and the clauses that hurt a small company, with wording to ask for), your cap table modelled through SAFEs, notes and a priced round, vesting schedules with leavers, acceleration and the 83(b) deadline, and your first office lease turned into its real commitment and exit dates. Each says what is worth a lawyer's hour.",
   "display_name": "Startup legal",
   "keywords": [
     "legal",
@@ -9,7 +9,10 @@
     "NDA",
     "SAFE",
     "cap table",
-    "dilution"
+    "dilution",
+    "vesting",
+    "83(b)",
+    "lease"
   ],
   "links": {
     "documentation": "https://sananthanarayan.github.io/skilldrop/packs/startup-legal/"
@@ -37,7 +40,9 @@
     "when": "You're a founder without a lawyer on retainer, and an agreement, a round or a launch is coming.",
     "you_bring": [
       "the agreement you've been sent, or your own template",
-      "your cap table, SAFEs and any term sheet"
+      "your cap table, SAFEs and any term sheet",
+      "grant documents for anyone with vesting shares or options",
+      "the heads of terms or draft lease for an office"
     ],
     "steps": [
       {
@@ -51,8 +56,19 @@
         "you_do": "Give it your shareholders, SAFEs, notes and the term sheet.",
         "you_get": "What each founder and investor owns after the round, what each SAFE converted at, and what the pool top-up cost you.",
         "decide": "Which valuation and pool terms to negotiate for."
+      },
+      {
+        "skill": "vesting-schedule",
+        "you_do": "Give it each grant's shares, start date and terms, and any leaving date.",
+        "you_get": "Cliff and fully-vested dates, what is vested on any date, leaver outcomes, and the 83(b) deadline as an exact date."
+      },
+      {
+        "skill": "lease-check",
+        "you_do": "Give it the heads of terms or the draft lease.",
+        "you_get": "What signing commits you to up to each break and to the end, every notice deadline as a date, and the clauses to push back on with wording.",
+        "decide": "Sign, negotiate, or take the guarantee or break clause to a lawyer."
       }
     ],
-    "you_end_with": "Agreements you understand before signing, and a cap table you can defend in a negotiation."
+    "you_end_with": "Agreements you understand before signing, a cap table and vesting schedule you can defend, and an office lease whose cost and exits you know."
   }
 }

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.