@damiangilgonzalez/harness 1.3.7

package/skills/continuous-learning/evals/cases.yaml

@@ -0,0 +1,39 @@
+skill: continuous-learning
+
+should_trigger:
+  - prompt: "We just resolved that nasty outage. Run a quick retro so we actually learn from it."
+    why: "Canonical retro/postmortem moment — harvest the lesson into a durable home, not just talk about it."
+  - prompt: "You keep stripping the YAML frontmatter when you edit skills — I've fixed it three times now. Make it stop for good."
+    why: "Recurring correction past the 2+ threshold; 'make it stop for good' demands a structural guardrail, not another apology."
+  - prompt: "Apúntate esta lección para que no volvamos a cometer el mismo error con las migraciones."
+    why: "Spanish verbatim 'save this lesson so we don't repeat the migration mistake' — explicit backward-lesson capture."
+  - prompt: "Now that debug found the root cause, make sure we never ship this pattern again."
+    why: "Non-obvious post-debug capture; the teaching point is the boundary with debug — capture runs after diagnosis."
+  - prompt: "Sweep all the little 'note to self' corrections from this week into wherever they actually belong."
+    why: "Non-obvious harvest/route phrasing with no 'lesson' keyword; this is the periodic-sweep entry point."
+
+should_not_trigger:
+  - prompt: "Document why we chose Postgres over Mongo, with the options we rejected."
+    route_to: write-adr
+    why: "Forward choice with alternatives belongs in write-adr, not a backward lesson from a mistake."
+  - prompt: "Write the SKILL.md and the evals for a new pr-describe skill."
+    route_to: author-skill
+    why: "Skill craft; continuous-learning only decides a lesson belongs in a skill and hands the edit over."
+  - prompt: "Find why the checkout endpoint is returning 500."
+    route_to: external:superpowers-systematic-debugging
+    why: "In-the-moment diagnosis is superpowers' systematic-debugging; capture comes after the root cause is found."
+  - prompt: "Set up a recurring weekly job that runs our retro automatically."
+    route_to: harness
+    why: "Scheduling cadence is the harness/loop CLI; this skill is not a scheduler, it only recommends a cadence."
+
+capability:
+  - scenario: "A user says: 'You've now twice deleted my .env when scaffolding a tool. I'm tired of catching it. Make sure this never happens again.' Show how continuous-learning captures it."
+    must_include:
+      - "Reads docs/wiki/harness/user-profile.md for the accompaniment dial and adapts narration to L0–L3."
+      - "States the root cause blamelessly as a system gap (a missing guardrail), not 'I was careless'."
+      - "Applies the 2+-recurrences rule: this is the 2nd time, so a structural fix is required — not another apology or note."
+      - "Routes to the right durable home via the table: a root CLAUDE.md rule and/or a verify.sh check on the scaffolding skill, naming the exact path."
+      - "Delegates the actual SKILL.md / eval / verify.sh edit to author-skill where skill craft is required, rather than hand-editing it."
+      - "Writes the lesson in the situation-tagged entry format (situation, we believed, actually, durable home, fires next time)."
+      - "Proves it fires next time by pointing to the concrete surface (rule / should_not_trigger eval / verify.sh check) that catches the regression, and notes this skill emits no artifact of its own — the check lives there."
+      - "Keeps prose original in rsc voice; no copied signature artifacts."

package/skills/continuous-learning/references/lesson-routing.md

@@ -0,0 +1,106 @@
+# Lesson routing catalogue
+
+The body table covers routine cases. This is the exhaustive catalogue: every
+lesson archetype, its canonical durable home, the exact path, and the hand-off
+recipe (who edits, what the verify is). Read it when the home or the hand-off
+is unobvious.
+
+## Archetype → home → hand-off
+
+### About the user
+- **Looks like:** "I prefer X", "I always want Y", "stop asking me Z", a working
+  style you inferred from repeated corrections.
+- **Home:** `docs/wiki/harness/user-profile.md` (the living portrait).
+- **Who writes:** this skill, directly.
+- **Verify:** the next pass reads the profile and the behaviour changes. Confirm
+  the line is in the profile, not just the chat.
+
+### A rule we keep breaking (workspace-wide)
+- **Looks like:** "never commit to main", "always use absolute paths", "don't
+  touch `.env`".
+- **Home:** a rule under the relevant heading in the root `CLAUDE.md`.
+- **Who writes:** this skill (CLAUDE.md is harness-owned plain text, not skill
+  craft).
+- **Verify:** the rule is phrased as an imperative the agent can act on, and a
+  later pass that reads `CLAUDE.md` would catch the regression.
+
+### A rule that belongs to one skill
+- **Looks like:** "the deploy skill should always run a smoke check first".
+- **Home:** the owning skill's `SKILL.md` body (a rule line) and, if it bans a
+  pattern, a `should_not_trigger` or a `verify.sh` check.
+- **Who writes:** **`author-skill`** — you decide the rule belongs there and
+  hand over the edit. Do not edit the body yourself.
+- **Verify:** the rule appears in the body *and* an eval/check exists that fails
+  on the old behaviour.
+
+### A pattern to ban (code/config/copy)
+- **Looks like:** "never use `cd` in compound bash commands", "no `console.log`
+  in committed code", "ban the phrase 'leverage synergies'".
+- **Home:** a banlist/grep check in the owning skill's `scripts/verify.sh`.
+- **Who writes:** `author-skill`.
+- **Verify:** `verify.sh` exits non-zero on a file containing the banned
+  pattern, and exits 0 on a clean target.
+
+### A missed-trigger insight
+- **Looks like:** "the skill fired on a prompt it should have routed elsewhere",
+  "it failed to fire on this obvious phrasing".
+- **Home:** a `should_not_trigger` (with `route_to`) or `should_trigger` case in
+  the skill's `evals/cases.yaml`.
+- **Who writes:** `author-skill`.
+- **Verify:** the new case encodes the exact prompt that misfired.
+
+### A surprising fact / how a provider behaves
+- **Looks like:** "Stripe webhooks retry with exponential backoff for 3 days",
+  "this API rate-limits per-IP not per-key".
+- **Home:** a wiki article via the harness ingest protocol, linked from the
+  `## Knowledge map`.
+- **Who writes:** `harness`.
+- **Verify:** the article exists and the Knowledge map links it, so the next
+  skill working in that area reads it.
+
+### A forward choice that surfaced mid-retro
+- **Looks like:** the retro reveals you now need to *choose* something going
+  forward (architecture, vendor, approach).
+- **Home:** `docs/wiki/harness/decisions.md` as a decision record.
+- **Who writes:** `decision-records`. Punt cleanly — do not log a choice as a
+  lesson.
+
+### A one-off, low-stakes note
+- **Looks like:** a small observation with no recurrence risk and no class to
+  kill.
+- **Home:** an append to `docs/wiki/harness/decisions.md`, or a topic note in
+  the wiki.
+- **Who writes:** this skill.
+- **Verify:** lightweight — the note is durable and dated. If the same note
+  recurs, escalate it via the 2+-recurrences rule to a guardrail.
+
+## Worked example — the recurring `cd` mistake
+
+Trigger: "You keep running `cd somedir && cmd` in bash and it triggers a
+permission prompt every time. I've corrected this three times."
+
+1. **Harvest** — the lesson: compound `cd` in bash breaks the sandbox; use
+   absolute paths instead.
+2. **Root-cause, blameless** — *system* gap: no workspace rule forbids `cd` in
+   compound commands. Not "the agent is sloppy".
+3. **Route** — three sightings ⇒ structural fix, not a note. Two homes:
+   - a rule in root `CLAUDE.md`: "Never `cd` in a compound bash command; use
+     absolute paths." → written by this skill.
+   - optionally, a grep check in the owning tooling skill's `verify.sh` that
+     flags `cd .* &&` in committed scripts. → handed to `author-skill`.
+4. **Write** — land both, in the lesson entry format, with the durable home and
+   the "fires next time" line filled.
+5. **Verify it fires** — the `CLAUDE.md` rule is read on the next pass; the
+   `verify.sh` grep fails on a script containing `cd foo && bar` and passes on a
+   clean one. Now it is captured.
+
+Lesson entry that results:
+
+```md
+## 2026-06-02 — No `cd` in compound bash commands
+- **Situation:** writing or running bash that changes directory then runs a command
+- **We believed:** `cd dir && cmd` is harmless shorthand
+- **Actually:** it trips the sandbox permission prompt every time; absolute paths don't
+- **Durable home:** root `CLAUDE.md` rule + grep check in the tooling skill's verify.sh
+- **Fires next time via:** CLAUDE.md rule read each pass; verify.sh fails on `cd .* &&`
+```

package/skills/contracts/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: contracts
+description: "Use when drafting or reviewing business contracts and clauses in plain language — NDAs, MSAs, SOWs, contractor agreements, risk boilerplate (liability caps, indemnity, force majeure, termination, IP) — or redlining a counterparty's paper. NOT consumer Terms of Service (that is terms-conditions) and NOT the signing workflow (that is e-signature)."
+tags: [contracts, legal, ndas, msa, sow, clauses, redlining, risk-allocation]
+recommends: [terms-conditions, e-signature, gdpr-privacy, proposals, ip-trademark, invoicing]
+origin: risco
+---
+
+# Contracts
+
+You draft and review everyday business contracts and individual clauses in plain language. You are not a lawyer and you never say you are. Your job is to produce a clean, redline-ready draft or a risk-flagged review that a founder can actually read — and to hand off anything that allocates real liability to a licensed attorney before it is signed.
+
+## First move: identify the instrument and the side
+
+Before drafting a word, fix two things: **which instrument** this is, and **which side the operator is on**. Every default flips on the side. A liability cap that is generous to the buyer is dangerous to the seller; an indemnity that protects the discloser exposes the recipient. Ask "are we the buyer or the seller? the discloser or the recipient?" first.
+
+| Instrument | What it governs | Who usually has leverage | The one clause that matters most |
+|---|---|---|---|
+| NDA (mutual / one-way) | Confidential information only | Discloser sets terms in one-way | Definition of "Confidential Information" + return/destroy + term |
+| MSA (Master Service Agreement) | The whole relationship: services, payment, liability | Larger party drafts | Limitation of liability + indemnity |
+| SOW (Statement of Work) | One project: deliverables, timeline, price | The buyer scopes | Acceptance criteria + change control (must not contradict the MSA) |
+| Consulting / contractor agreement | A person's work + IP + payment | The hiring company | IP assignment vs license + worker classification |
+| Single-clause edit | One allocation of risk | Whoever proposed the language | The carve-outs the clause is missing |
+
+If the operator hasn't told you their side, ask. Do not guess — a wrong guess inverts every default.
+
+## Plain-language drafting rules
+
+- **One obligation per sentence.** Two obligations in one sentence hide one of them.
+- **Define a term once, then capitalize it.** "the Services" beats re-describing the work five times with slightly different words; drift between descriptions is how scope disputes start.
+- **Active voice with a named actor.** "Supplier shall deliver" tells you who is on the hook; "delivery shall be made" does not.
+- **Numbers, not words, for money and time.** Write "$10,000" and "30 days", not "ten thousand dollars" and "thirty days" — numerals are unambiguous and skimmable.
+- **Ban archaic legalese.** `heretofore`, `hereinafter`, `witnesseth`, `party of the first part`, `aforesaid` add nothing and signal a copied template nobody read.
+
+```text
+Bad:  WHEREAS the party of the first part, hereinafter referred to as the
+      Disclosing Party, shall, prior to such time as disclosure is made,
+      cause to be delivered notice aforesaid.
+Good: Before sharing Confidential Information, the Disclosing Party shall
+      label it "Confidential."
+```
+
+```text
+Bad:  Indemnification shall be provided in respect of any and all claims
+      whatsoever arising hereunder.
+Good: Each party shall defend the other against third-party claims caused by
+      that party's breach of this agreement or its negligence. (See cap below.)
+```
+
+"Any and all claims" is not just ugly — it is unlimited exposure. Narrow phrasing is a risk decision, not a style choice.
+
+```text
+Bad:  The Agreement may be terminated forthwith in the event of breach.
+Good: Either party may terminate if the other materially breaches and fails to
+      cure within 30 days after written notice. (Who can terminate, and when.)
+```
+
+## The clauses that allocate risk
+
+Every clause below moves money or blame from one party to the other when something goes wrong, so state who pays in one line beside the clause you emit. For each: what it allocates, the safe default, the carve-outs. Copy-ready text lives in `references/clause-library.md`.
+
+**Limitation of liability** — allocates *how much* one party can lose when the deal goes wrong. Safe default: aggregate liability capped at the fees paid in the trailing 12 months. Carve-outs (uncapped) for breach of confidentiality and indemnity obligations. You *cannot* cap liability for fraud, intentional misconduct, or bodily harm — courts will strike those exclusions, so don't write them.
+
+**Indemnity** — allocates *who defends and pays* when a third party sues. Draw it narrowly: claims arising from the indemnifying party's breach, negligence, or third-party IP claims — never "any and all claims," which is unlimited exposure. Cap it (often together with the liability cap), and set a survival period; 3–5 years is common. Make it mutual where leverage is even.
+
+**Force majeure** — allocates *who bears the loss* when neither party is at fault. Use a defined term plus a catch-all ("...and any other event beyond the party's reasonable control"); exhaustive lists routinely miss real events like floods and cyberattacks. Require prompt notice and a duty to mitigate, and add a right to terminate if the event persists past a stated period (e.g. 30 days). The ICC publishes a model clause (last updated March 2020) you can anchor to.
+
+**Termination** — allocates *who can walk and on what notice*. Distinguish termination *for cause* (with a cure period — e.g. 30 days to fix a breach) from termination *for convenience* (notice, no reason needed). A convenience right that only one side holds is a red flag; push for mutuality or delete it.
+
+**IP / ownership** — allocates *who owns what gets made*. Assignment transfers ownership to the buyer; a license lets the buyer use it while the creator keeps it. For contractors, default to written assignment of deliverables with the contractor retaining pre-existing/background IP under a license.
+
+**Confidentiality and governing law/venue** — keep both tight. Confidentiality: define the info, set a term, require return-or-destroy on termination. Governing law/venue: pick one jurisdiction explicitly; an unstated venue is a fight waiting to happen.
+
+## Review mode: redline a counterparty's paper
+
+When the operator hands you the other side's draft, pass through it in this order so you never miss the expensive parts:
+
+1. **Parties** — correct legal entities, signing authority.
+2. **Scope** — does it match what was actually agreed?
+3. **Price / payment** — amounts, milestones, late-payment terms.
+4. **The risk clauses** — liability cap, indemnity, force majeure, termination, IP. This is where the money is.
+5. **Boilerplate** — governing law, assignment, entire-agreement, amendment.
+
+Separate **non-negotiables** (uncapped liability, one-way indemnity, IP grab that takes your background IP) from **nice-to-haves** (a longer cure period, tighter notice). Spend your leverage on the first list.
+
+Tells of a one-sided draft: uncapped indemnity; "mutual" obligations that only bind you on inspection; auto-renewal with a long opt-out notice window; a termination-for-convenience right only the counterparty holds; a liability cap with no confidentiality/indemnity carve-out (good for them, bad for you). The full demand/concede/flag checklist per clause, plus the MSA↔SOW reconciliation steps, is in `references/review-playbook.md`.
+
+## MSA + SOW: rulebook and playbook
+
+The MSA is the rulebook — it governs services, payment, and liability for the whole relationship. The SOW is the playbook for one project — deliverables, timeline, project price. An NDA is narrower than both: it only protects confidential information.
+
+Before signing an SOW under an existing MSA, cross-check that the SOW does not contradict the MSA (a different liability cap or payment term hidden in the SOW is a trap). Reconcile any conflict explicitly — state which document controls — before either is signed.
+
+## The legal boundary
+
+- **You do not give legal advice.** Every US state's Unauthorized Practice of Law statutes bar non-lawyers from drafting legal documents for others or advising on them; ABA Formal Opinion 512, issued 2024-07-29, keeps the attorney fully responsible for AI-generated legal work, and AI providers disclaim liability for errors. You draft and review and flag — that's it.
+- **Emit the attorney-review line** on any full-contract draft, any edit that allocates real liability, or any jurisdiction you cannot verify: "Have a licensed attorney review this before signing." This one is absolute — without it a draft reads as cleared to sign, which is the false sense of safety that gets people hurt.
+- **Warn before pasting confidential paper into untrusted AI tools.** ABA Op. 512 advises informed consent before inputting confidential information into self-learning public tools. If the operator is about to paste a counterparty's confidential contract somewhere unvetted, say so first.
+- **Hand off the edges:** the signing flow (signer order, audit trail, ESIGN/UETA/eIDAS compliance of the signature itself) → `../e-signature/SKILL.md`; consumer-facing site policies → `../terms-conditions/SKILL.md`; privacy substance of a DPA or how personal data is processed → `../gdpr-privacy/SKILL.md`; the pitch that wins the deal (not the binding paper) → `../proposals/SKILL.md`; trademark/IP strategy beyond a contract clause → `../ip-trademark/SKILL.md`; the customer invoice as a billing artifact → `../invoicing/SKILL.md`.
+
+A note on signatures so you don't over-promise: a contract or signature cannot be denied legal effect *solely* because it is electronic — that is the shared core of the US ESIGN Act (2000), UETA (49 states + DC + territories), and EU eIDAS. The US uses a single technology-neutral tier; the EU uses three (Simple / Advanced / Qualified), where a Qualified Electronic Signature carries the legal weight of a handwritten one. The mechanics belong to `../e-signature/SKILL.md`.
+
+## Anti-patterns
+
+| Anti-pattern | Why it bites | Fix |
+|---|---|---|
+| Copies a template without flipping buyer/seller defaults | Every default protects whoever wrote the template, often the other side | Identify the operator's side first; invert each default to favor them |
+| Drafts in legalese the operator can't read | An unreadable contract can't be negotiated or enforced confidently | One obligation per sentence, defined terms, active voice, no archaic words |
+| Caps liability but forgets to carve out confidentiality + indemnity | A blanket cap quietly limits the clauses that protect you most | Always add the carve-outs; never try to cap fraud/willful misconduct/bodily harm |
+| Reviews boilerplate but skips the SOW-vs-MSA conflict | A contradictory term in the SOW silently overrides the MSA's protections | Cross-check SOW against MSA; state which controls before signing |
+| Exhaustive force-majeure list with no catch-all | The one event that happens is the one not listed | Defined term + catch-all + notice + mitigation + terminate-if-persists |
+| Claims the draft is "legally binding" or "safe" without attorney review | Crosses into legal advice and UPL; AI errors are disclaimed | State you are not a lawyer; emit the attorney-review line on liability-allocating work |
+| Pastes a counterparty's confidential contract into an untrusted tool | Leaks confidential terms; breaches ABA Op. 512 guidance | Warn the operator and get informed consent before inputting confidential text |

package/skills/contracts/evals/README.md

@@ -0,0 +1,3 @@
+# Evals: contracts
+
+These cases are routing and coverage checks, not an automated pass/fail suite. Read `cases.yaml` against `SKILL.md`. For each `should_trigger` prompt, confirm the description and body would plausibly fire this skill and not a sibling; for each `should_not_trigger` prompt, confirm the named `route_to` sibling is the better home and that this skill's boundary text would defer to it. For the `capability` case, draft (or have a harness LLM draft) the redline and check it hits every item in `must_include` — most importantly that it identifies the operator's side, fixes each one-sided clause, writes in plain language, and emits the attorney-review boundary. A human or an LLM judge runs these by reading; there is no scripted assertion. The separate `scripts/verify.sh` is the only automated check, and it inspects a generated draft artifact, not these cases.

package/skills/contracts/evals/cases.yaml

@@ -0,0 +1,42 @@
+skill: contracts
+
+should_trigger:
+  - prompt: "Draft a mutual NDA between us and a freelance designer."
+    why: Core instrument — drafting a confidentiality agreement, the canonical contracts task.
+  - prompt: "Review this MSA the vendor sent and tell me what to push back on."
+    why: Review mode on a counterparty's negotiated paper; redline of risk clauses.
+  - prompt: "Make this indemnification clause mutual and cap it."
+    why: Non-obvious single-clause edit — flipping a one-way indemnity and adding a cap.
+  - prompt: "Write an SOW under our existing MSA for the Q3 build."
+    why: Non-obvious — SOW/MSA relationship and the cross-check that the SOW not contradict the MSA.
+  - prompt: "Revisa este contrato de prestación de servicios antes de firmarlo."
+    why: Spanish trigger; review of a two-party services agreement before signing.
+  - prompt: "Add a force majeure clause with a catch-all to our supplier agreement."
+    why: Specific risk-allocating boilerplate; defined term plus catch-all is the skill's exact rule.
+
+should_not_trigger:
+  - prompt: "Write the Terms of Service for our SaaS website."
+    route_to: terms-conditions
+    why: One-to-many published policy, not a negotiated two-party agreement.
+  - prompt: "Send this signed contract out for e-signature in the right signer order."
+    route_to: e-signature
+    why: Signing workflow and audit trail, not drafting or reviewing the agreement.
+  - prompt: "Draft our privacy policy and how we handle user personal data."
+    route_to: gdpr-privacy
+    why: Privacy substance and data handling, not contract terms between two parties.
+  - prompt: "Write a sales proposal to win the consulting deal."
+    route_to: proposals
+    why: A pitch to win the deal, not the binding legal agreement.
+  - prompt: "Create the invoice and payment terms for this client."
+    route_to: invoicing
+    why: A billing artifact, not a negotiated contract.
+
+capability:
+  - scenario: "We're the recipient in a one-way NDA the customer sent. It has an uncapped indemnity, a 5-year confidentiality tail with no return-of-info clause, and a unilateral termination-for-convenience right for them. Redline it in our favor and explain each change."
+    must_include:
+      - Identifies the operator's side (recipient) and flips defaults to favor the recipient
+      - Flags the uncapped indemnity and proposes a cap plus narrowed scope (breach/negligence/third-party IP)
+      - Addresses the confidentiality tail by adding a return-or-destroy-on-termination obligation
+      - Flags the one-sided termination-for-convenience right and proposes mutuality or deletion
+      - Rewrites in plain language with no archaic legalese (no heretofore/witnesseth/party of the first part)
+      - Emits the licensed-attorney-review boundary before signing

package/skills/contracts/references/clause-library.md

@@ -0,0 +1,129 @@
+# Clause library
+
+Copy-ready, plain-language clause templates. Fill the `[BRACKETED]` parts. Each opens with one line on **what it allocates**. These are starting drafts, not legal advice — have a licensed attorney review before signing.
+
+## Mutual NDA core
+
+*Allocates: who may use shared confidential information, and for how long.*
+
+```text
+"Confidential Information" means non-public information a party discloses that
+is marked confidential or that a reasonable person would treat as confidential.
+It does not include information that is public, already known to the recipient,
+or independently developed without using the disclosure.
+
+Each party shall use the other's Confidential Information only to [PURPOSE],
+shall not disclose it to third parties except to employees and contractors who
+need it and are bound by similar duties, and shall protect it with at least
+reasonable care. These duties last [3] years from disclosure. On termination or
+on request, each party shall return or destroy the other's Confidential
+Information and confirm in writing.
+```
+
+## Limitation of liability (with carve-outs)
+
+*Allocates: the maximum each party can lose when the deal goes wrong.*
+
+```text
+Except for the Carve-Outs below, each party's total liability under this
+agreement is capped at the fees paid or payable by [CUSTOMER] in the 12 months
+before the event giving rise to the claim. Neither party is liable for indirect,
+incidental, or consequential damages.
+
+Carve-Outs (not subject to the cap): a party's confidentiality breaches and its
+indemnification obligations. Nothing in this agreement limits liability for
+fraud, willful misconduct, or bodily harm/death.
+```
+
+Note: do not attempt to cap fraud, willful misconduct, or bodily harm — those exclusions are generally unenforceable.
+
+## Mutual indemnity (narrow + capped)
+
+*Allocates: who defends and pays when a third party sues.*
+
+```text
+Each party (the "Indemnifying Party") shall defend the other against third-party
+claims to the extent caused by the Indemnifying Party's breach of this agreement,
+its negligence or willful misconduct, or its infringement of a third party's
+intellectual-property rights, and shall pay damages and reasonable costs finally
+awarded. The indemnified party shall give prompt notice and reasonable
+cooperation, and the Indemnifying Party controls the defense and settlement
+(no settlement admitting fault without consent). This obligation survives [3]
+years after termination.
+```
+
+## Force majeure (defined term + catch-all)
+
+*Allocates: who bears the loss when neither party is at fault.*
+
+```text
+"Force Majeure Event" means an event beyond a party's reasonable control,
+including acts of God, flood, fire, war, terrorism, epidemic, government action,
+labor disruption, failure of utilities or carriers, cyberattack, and any other
+similar event beyond the party's reasonable control.
+
+A party affected by a Force Majeure Event is excused from performance (except
+payment obligations already due) for as long as the event continues, provided it
+gives prompt written notice and uses reasonable efforts to mitigate. If the event
+continues for more than [30] days, either party may terminate on written notice.
+```
+
+(Anchored to the ICC model force majeure clause, last updated March 2020.)
+
+## Termination — for cause and for convenience
+
+*Allocates: who can end the contract, on what notice, and with what cure period.*
+
+```text
+For cause: Either party may terminate if the other materially breaches and fails
+to cure within [30] days after written notice describing the breach.
+
+For convenience: Either party may terminate for any reason on [30] days' written
+notice. On termination, [CUSTOMER] shall pay for work performed through the
+termination date.
+```
+
+Keep convenience rights mutual. A one-way convenience right is a red flag.
+
+## IP — assignment vs license
+
+*Allocates: who owns what gets created, and what each side keeps.*
+
+```text
+Assignment (buyer owns deliverables): Contractor assigns to [CUSTOMER] all
+intellectual-property rights in the deliverables created under this agreement,
+effective on full payment.
+
+Background IP (contractor keeps its own): Contractor retains its pre-existing and
+independently developed materials ("Background IP") and grants [CUSTOMER] a
+non-exclusive, perpetual license to use Background IP embedded in the
+deliverables as needed to use them.
+```
+
+Use a *license* instead of assignment when the creator must keep ownership (e.g. reusable tooling) — say so explicitly.
+
+## Governing law and venue
+
+*Allocates: whose law applies and where disputes are heard.*
+
+```text
+This agreement is governed by the laws of [STATE/COUNTRY], without regard to its
+conflict-of-laws rules. The parties submit to the exclusive jurisdiction of the
+courts located in [VENUE] for any dispute arising under it.
+```
+
+## Entire agreement + amendment (boilerplate)
+
+*Allocates: which documents count, and how the contract can change.*
+
+```text
+This agreement (with its exhibits and any SOWs) is the entire agreement between
+the parties on its subject and supersedes prior discussions. It may be amended
+only by a written document signed by both parties. If an SOW conflicts with this
+agreement, this agreement controls unless the SOW expressly says otherwise and is
+signed by both parties.
+```
+
+---
+
+Reminder: these templates are drafting starting points. Have a licensed attorney review any contract before signing, especially clauses that allocate liability or cross a jurisdiction you cannot verify.

package/skills/contracts/references/review-playbook.md

@@ -0,0 +1,49 @@
+# Review playbook
+
+How to redline a counterparty's draft in the operator's favor. Read the clause they wrote, decide demand / concede / flag, propose plain-language replacement text. Always close with the attorney-review reminder.
+
+## Pass order
+
+Parties → scope → price/payment → risk clauses → boilerplate. The money is in the risk clauses; do not let boilerplate fatigue make you skim past them.
+
+## Demand / concede / flag per clause
+
+| Clause | Demand (non-negotiable) | Can concede | Flag if you see |
+|---|---|---|---|
+| Limitation of liability | A mutual cap with confidentiality + indemnity carve-outs | The exact multiple of fees | No cap at all; a cap that also limits *their* confidentiality breach |
+| Indemnity | Narrow scope (breach/negligence/third-party IP); cap; survival 3–5 yr | Survival length within 3–5 yr | "any and all claims"; one-way indemnity running only from you |
+| Force majeure | Defined term + catch-all + notice + mitigation | The persistence period before termination | Exhaustive list with no catch-all; excuses *their* payment obligations |
+| Termination | Mutual for-cause with cure period | The notice window | One-way termination-for-convenience; no cure period |
+| IP / ownership | Your background IP stays yours; deliverables assigned on payment | License vs assignment for edge assets | A grab of pre-existing/background IP; assignment before payment |
+| Confidentiality | Defined info, set term, return-or-destroy | Term length | Perpetual confidentiality with no return-of-info clause |
+| Auto-renewal | Short, mutual opt-out notice | Renewal term length | Auto-renew with a long (e.g. 90-day) opt-out window |
+| Governing law/venue | One explicit, workable jurisdiction | Which of two reasonable venues | Unstated venue; a venue you can't realistically litigate in |
+
+## Tells of a one-sided draft
+
+- An uncapped indemnity (or a cap that conveniently excludes only *their* breaches).
+- "Mutual" obligations that, read closely, only bind one party.
+- A liability cap with no confidentiality/indemnity carve-out — good for the drafter, bad for you.
+- A termination-for-convenience right held by only one side.
+- Auto-renewal with a long opt-out notice window.
+- IP language that sweeps in your pre-existing/background IP.
+
+## MSA ↔ SOW reconciliation
+
+1. List every term the SOW sets that the MSA also covers (price, liability, IP, payment).
+2. For each overlap, check the SOW does not contradict the MSA.
+3. If it does, decide which controls and state it in writing (default: the MSA controls unless the SOW expressly overrides and is signed by both).
+4. Resolve all conflicts *before* either document is signed — not after a dispute.
+
+## Jurisdiction caveats for the signing handoff
+
+The signature mechanics belong to `../e-signature/SKILL.md`, but flag the right tier when you hand off:
+
+- **US** — single, technology-neutral tier (ESIGN + UETA). Enforceability needs intent to sign, consent to do business electronically, a verifiable signer↔signature association, and retained reproducible records. Some documents are excluded (wills, certain family-law and notarial documents).
+- **EU (eIDAS)** — three tiers: Simple, Advanced, Qualified. A Qualified Electronic Signature (QES) carries the legal effect of a handwritten signature across all member states and needs a qualified certificate from a Qualified Trust Service Provider. eIDAS 2.0 adds the European Digital Identity Wallet.
+
+If a contract spans both regions or its enforceability depends on which signature tier is used, that is exactly the kind of cross-jurisdiction question a licensed attorney should confirm.
+
+---
+
+Reminder: a redline is a negotiating position, not legal advice. Have a licensed attorney review the final draft before signing.

package/skills/contracts/scripts/verify.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# verify.sh — plain-language + risk-carve-out discipline check for a contracts draft.
+# Read-only. Takes a generated contract/clause file as $1.
+# No argument => prints usage and exits 0 (never blocks when not given a draft).
+# Exits non-zero only when a real artifact violates a rule.
+set -euo pipefail
+
+artifact="${1:-}"
+
+if [ -z "$artifact" ]; then
+  echo "usage: verify.sh <contract-draft-file>"
+  echo "Checks a drafted contract/clause for archaic legalese, a liability cap"
+  echo "missing its carve-outs, and a missing attorney-review line."
+  echo "No file given — nothing to check."
+  exit 0
+fi
+
+if [ ! -f "$artifact" ]; then
+  echo "verify.sh: not a file: $artifact" >&2
+  exit 2
+fi
+
+fail=0
+
+# 1) Archaic legalese banlist (case-insensitive). Plain-language rule.
+legalese='heretofore|hereinafter|witnesseth|party of the first part|aforesaid'
+if grep -niE "$legalese" "$artifact" >/dev/null; then
+  echo "FAIL: archaic legalese — rewrite in plain language:"
+  grep -niE "$legalese" "$artifact" | sed 's/^/  /'
+  fail=1
+fi
+
+# 2) Liability cap present but no carve-out for confidentiality/indemnity/fraud.
+if grep -niE 'limit.*liabilit|aggregate liabilit|liability.*cap|capped at' "$artifact" >/dev/null; then
+  if ! grep -niE 'except|carve|carve-out|fraud|willful|confidential|indemnif' "$artifact" >/dev/null; then
+    echo "FAIL: a liability cap exists but no carve-out (confidentiality/indemnity) or fraud exclusion was found."
+    fail=1
+  fi
+fi
+
+# 3) Full-contract draft with no attorney-review line. Heuristic on length.
+lines=$(wc -l < "$artifact" | tr -d ' ')
+if [ "$lines" -ge 30 ]; then
+  if ! grep -niE 'attorney|legal counsel|qualified lawyer|licensed lawyer' "$artifact" >/dev/null; then
+    echo "FAIL: full-contract draft has no attorney-review line (add 'Have a licensed attorney review this before signing')."
+    fail=1
+  fi
+fi
+
+if [ "$fail" -eq 0 ]; then
+  echo "OK: $artifact passed plain-language and risk-carve-out checks."
+fi
+exit "$fail"