Skip to content

The open alternative to Salesforce, designed for AI.

Rework the twenty-partners Claude skills into a reviewable lead path (#23661)

Rashad Karanouh23e109a1c511
diff --git a/packages/twenty-apps/internal/twenty-partners/package.json b/packages/twenty-apps/internal/twenty-partners/package.json
index 5561b8945ee..000f8cc9c3f 100644
--- a/packages/twenty-apps/internal/twenty-partners/package.json
+++ b/packages/twenty-apps/internal/twenty-partners/package.json
@@ -1,12 +1,12 @@
{
"name": "twenty-partners",
- "version": "1.6.1",
+ "version": "1.6.2",
"license": "MIT",
"engines": {
"node": "^24.5.0",
"npm": "please-use-yarn",
"yarn": ">=4.0.2",
- "twenty": ">=2.23.0"
+ "twenty": ">=2.31.0"
},
"keywords": [],
"packageManager": "[email protected]",
@@ -27,8 +27,8 @@
},
"dependencies": {
"react-markdown": "^10.1.0",
- "twenty-client-sdk": "2.23.0-alpha.2",
- "twenty-sdk": "2.23.0-alpha.2",
+ "twenty-client-sdk": "2.31.0",
+ "twenty-sdk": "2.31.0",
"zod": "^4.1.11"
},
"devDependencies": {
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/_shared/partner-api.md b/packages/twenty-apps/internal/twenty-partners/src/skills/_shared/partner-api.md
new file mode 100644
index 00000000000..d4c986f6b16
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/skills/_shared/partner-api.md
@@ -0,0 +1,200 @@
+# Shared reference: credentials and API access
+
+Every `twenty-partner-*` / `twenty-lead-*` skill reads this file instead of restating
+credentials and queries. Fix a query here once, and every skill gets the fix.
+
+## Credentials
+
+All skills read `~/.twenty/credentials.env`:
+
+```env
+TWENTY_PARTNERS_API_URL=https://partners.twenty.com
+TWENTY_PARTNERS_API_KEY=<key>
+FIREFLIES_API_KEY=<key>
+```
+
+The partners key lives in `packages/twenty-apps/internal/twenty-partners/.env.prod`
+(gitignored). Copy it to `~/.twenty/credentials.env` on first setup. The Fireflies key is
+personal.
+
+Which skill needs what:
+
+| Skill | Partners URL + key | Fireflies key |
+|---|---|---|
+| `twenty-lead-brief` | yes (writes the Opportunity) | only for a Fireflies input |
+| `twenty-partner-shortlist` | yes (read-only) | no |
+| `twenty-partner-intro` | yes (writes Applications) | no |
+| `twenty-partner-recap` | yes | yes |
+| `twenty-partner-triage` | yes (read-only) | no |
+
+**If a required key is missing, stop and name it.** Never proceed on a partial set.
+
+## Helper
+
+```python
+import os, json, urllib.request
+
+creds = {}
+for line in open(os.path.expanduser("~/.twenty/credentials.env")):
+ line = line.strip()
+ if line and "=" in line and not line.startswith("#"):
+ k, v = line.split("=", 1); creds[k] = v.strip()
+
+def gql(url, key, query, variables=None):
+ body = json.dumps({"query": query, "variables": variables or {}}).encode()
+ req = urllib.request.Request(url, data=body, headers={
+ "Content-Type": "application/json",
+ "Authorization": "Bearer " + key,
+ "User-Agent": "Mozilla/5.0"})
+ return json.load(urllib.request.urlopen(req, timeout=90))
+```
+
+The `User-Agent` header is not optional: the Fireflies API rejects urllib's default.
+
+Partners endpoint: `$TWENTY_PARTNERS_API_URL/graphql`.
+Fireflies endpoint: `https://api.fireflies.ai/graphql`.
+
+## Partner queries
+
+**All partners available for work** (`twenty-partner-shortlist`). Paginate until
+`hasNextPage` is false, passing `endCursor` as `$after`.
+
+```graphql
+query ListPartners($after: String) {
+ partners(
+ filter: { validationStage: { eq: VALIDATED }, availability: { eq: AVAILABLE } }
+ after: $after
+ ) {
+ pageInfo { hasNextPage endCursor }
+ edges { node {
+ id name slug introduction
+ languagesSpoken country region city
+ deploymentExpertise partnerScope skills typeOfTeam
+ partnerTier ranking
+ twentyExperience twentyExperienceNotes
+ hourlyRate { amountMicros currencyCode }
+ projectBudgetMin { amountMicros currencyCode }
+ lastMatchAt
+ persons { edges { node { name { firstName lastName } emails { primaryEmail } } } }
+ company { id name domainName { primaryLinkUrl } }
+ } }
+ }
+}
+```
+
+`amountMicros` is the amount times 1,000,000. Divide before displaying.
+
+**All partners with contact + domain** (`twenty-partner-recap`, matching an attendee):
+
+```graphql
+query($a:String){ partners(after:$a){
+ pageInfo{ hasNextPage endCursor }
+ edges{ node{
+ id name slug validationStage
+ persons{ edges{ node{ name{ firstName lastName } emails{ primaryEmail } } } }
+ company{ name domainName{ primaryLinkUrl } } } } } }
+```
+
+## Opportunity queries
+
+**Find an existing Opportunity before creating one** (`twenty-lead-brief`):
+
+```graphql
+query($n:String!){ opportunities(filter:{ name:{ ilike:$n } }, first:5){
+ edges{ node{ id name stage createdAt company{ name } } } } }
+```
+
+**Create** (`twenty-lead-brief`):
+
+```graphql
+mutation($d:OpportunityCreateInput!){ createOpportunity(data:$d){ id name } }
+```
+
+**Update** (`twenty-partner-intro`, to stamp `introSentAt`):
+
+```graphql
+mutation($id:UUID!,$d:OpportunityUpdateInput!){ updateOpportunity(id:$id,data:$d){ id } }
+```
+
+`designDocUrl` is a LINKS field: `{ "primaryLinkUrl": "<url>", "primaryLinkLabel": "Partner brief" }`.
+
+## Application queries
+
+An `Application` links a partner to an opportunity. State `INVITED` means Twenty pushed the
+partner at the lead; `APPLIED` means the partner came forward on their own.
+
+```graphql
+query($oid:UUID!){ applications(filter:{ opportunityId:{ eq:$oid } }){
+ edges{ node{ id state partner{ id name } } } } }
+
+mutation($d:ApplicationCreateInput!){ createApplication(data:$d){ id state } }
+# variables: { "d": { "opportunityId": "<id>", "partnerId": "<id>", "state": "INVITED" } }
+```
+
+## Company and person
+
+`twenty-lead-brief` needs a `companyId` and a `pointOfContactId` on the Opportunity. Search
+first, create only on a miss.
+
+```graphql
+query($n:String!){ companies(filter:{ name:{ ilike:$n } }, first:5){
+ edges{ node{ id name } } } }
+mutation($d:CompanyCreateInput!){ createCompany(data:$d){ id name } }
+
+query($e:String!){ people(filter:{ emails:{ primaryEmail:{ eq:$e } } }, first:1){
+ edges{ node{ id name{ firstName lastName } } } } }
+mutation($d:PersonCreateInput!){ createPerson(data:$d){ id } }
+```
+
+## Note queries
+
+```graphql
+query($pid:UUID!){ noteTargets(filter:{ targetPartnerId:{ eq:$pid } }){
+ edges{ node{ note{ id title bodyV2{ markdown } createdAt } } } } }
+
+mutation($d:NoteCreateInput!){ createNote(data:$d){ id title } }
+mutation($d:NoteTargetCreateInput!){ createNoteTarget(data:$d){ id targetPartnerId } }
+mutation($id:UUID!,$d:NoteUpdateInput!){ updateNote(id:$id,data:$d){ id } }
+```
+
+## Fireflies queries
+
+`date` is epoch milliseconds. `limit` is capped at 50: a higher value is a hard
+`invalid_arguments` 400, not a soft clamp.
+
+```graphql
+query{ transcripts(limit:50){ id title date duration participants
+ meeting_attendees{ displayName email } } }
+
+query($id:String!){ transcript(id:$id){
+ title date duration participants host_email organizer_email
+ meeting_attendees{ displayName email }
+ summary{ overview short_summary keywords }
+ sentences{ speaker_name text } } }
+
+mutation($id:String!){ deleteTranscript(id:$id){ id title } }
+```
+
+A Fireflies URL is `app.fireflies.ai/view/<slug>::<ID>`. The ID is the trailing `01K…`
+segment.
+
+## Opening a Gmail draft in Chrome
+
+```python
+import subprocess, urllib.parse, time, sys
+params = {"view": "cm", "fs": "1", "to": to, "su": subject, "body": body}
+if cc: params["cc"] = cc
+url = "https://mail.google.com/mail/?" + urllib.parse.urlencode(params)
+if sys.platform == "darwin":
+ subprocess.run(["open", "-a", "Google Chrome", url])
+else:
+ import webbrowser; webbrowser.open(url)
+time.sleep(1.5)
+```
+
+Two limits, both real:
+
+- A `view=cm` URL always opens a **new** compose. It cannot reply inside an existing
+ thread. A reply must be handed to the user as text to paste.
+- A long body overflows the URL. Keep bodies to a few short paragraphs and link to the
+ brief rather than pasting it.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-lead-brief/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-lead-brief/SKILL.md
new file mode 100644
index 00000000000..b010367a951
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-lead-brief/SKILL.md
@@ -0,0 +1,231 @@
+---
+name: twenty-lead-brief
+description: Turn a Twenty sales/discovery call into a partner-ready brief and record the lead in the CRM. Use whenever the user has a call recording, transcript, Fireflies link, or a lead folder and wants to qualify the deal, summarize the call, write a partner brief, or prep the partner handoff. Trigger even without the word "brief" - "summarize this call", "what did we learn from the X call", "qualify this lead", "scope this for a partner", "draft a design doc", or pointing at a transcript file all count. Produces a qualification summary, a partner brief, matching criteria, and an Opportunity in the partners workspace. Pass --full for inference mode.
+trigger: /twenty-lead-brief
+---
+
+# twenty-lead-brief
+
+First step of the lead path. Takes a raw call and produces everything the rest of the path
+needs:
+
+```
+twenty-lead-brief → twenty-partner-shortlist → twenty-partner-intro
+```
+
+Four outputs, in order:
+
+1. A **qualification summary** printed in the conversation. You can stop here.
+2. A **partner brief** the partner reads to scope and quote.
+3. **`partner-match-criteria.md`**, the input to `twenty-partner-shortlist`.
+4. An **Opportunity** in the partners workspace, carrying the brief's URL.
+
+Credentials, the `gql()` helper and every query live in `../_shared/partner-api.md`. Read it
+rather than restating anything.
+
+---
+
+## Step 1 — Get the transcript
+
+The user provides it: pasted text, a path (`.txt` / `.vtt` / `.srt`, a meetily folder or
+`transcripts.json`), or a Fireflies link or ID.
+
+- meetily `transcripts.json` is `{ "segments": [ { "text": … } ] }`: concatenate `text` in
+ order.
+- `.vtt` / `.srt`: drop cue numbers and timecodes.
+- Fireflies: fetch the transcript detail (see the shared reference). Needs `FIREFLIES_API_KEY`.
+
+**No transcript means stop and ask.** Never fabricate one, never proceed without one.
+
+For a long transcript, read the whole thing before writing. Coverage is the point.
+
+---
+
+## Step 2 — The qualification summary
+
+A **structured extraction against a fixed schema**, not a summary. A "summary that loses
+nothing" is a contradiction; the schema is what prevents loss, because every dimension has a
+slot and a gap is marked rather than silently dropped.
+
+**Rules**
+
+- Extract ONLY what is in the transcript. If a field isn't covered, write "Not discussed."
+ A visible gap beats a confident fabrication: it is the signal to ask on the next call.
+- Separate stated FACTS from your INFERENCES. Mark any inference "(inferred)". Downstream
+ matching trusts the facts, so don't contaminate them with guesses.
+- Preserve specifics verbatim: numbers, dates, names and roles, tool and CRM names, prices,
+ budgets, exact requirements. Never round or paraphrase a number. Specifics are where the
+ matching signal lives.
+- Use the customer's own words for needs and objections. Quote pivotal lines.
+- Don't smooth over a contradiction or a vagueness: note it. A flagged contradiction is more
+ useful than a falsely tidy summary.
+- With no speaker labels, infer from context who is Twenty and who is the prospect.
+ Speech-to-text garbles names: flag an uncertain one "(uncertain)" and never invent one.
+- Keep PART A tight: it is the one-pager the rest of the path runs on. Push anything not
+ specific to this deal into PART B. State each fact once.
+
+**Output (these exact headers)**
+
+```
+== PART A — DEAL ONE-PAGER ==
+
+1. ONE-LINE SUMMARY
+2. COMPANY — name, what they do, size/employees, HQ + countries of operation, industry
+3. PEOPLE ON THE CALL — name, role/title, side (Twenty vs prospect); infer roles if
+ unlabeled and flag uncertain names
+4. CURRENT SITUATION — what CRM/tools they use today; specific pains
+5. WHY THEY'RE INTERESTED IN TWENTY
+6. WHAT THEY WANT — bulleted needs/requirements, verbatim where possible
+7. IMPLEMENTATION COMPLEXITY (for partner matching)
+ - Deployment: cloud / self-host / both / unclear (+ the evidence)
+ - Data model: custom objects, multi-tenant, row-level security, migrations
+ - Integrations / custom apps needed
+ - Workflows / automation needs
+ - Scale: number of seats/users
+ - Region + language the partner would need to cover
+8. COMMERCIALS — budget or prices discussed, plan tier (Pro/Org/Enterprise), seat count,
+ deal value, who pays
+9. TIMELINE & DECISION — key dates, decision-makers, urgency, decision process
+10. OBJECTIONS / RISKS / FEARS — including anything that could kill the deal
+11. ALTERNATIVES — competitors or other options they're weighing
+12. DOES THIS DEAL NEED A PARTNER? — yes / no / maybe + why; and if yes, what kind
+ (scope, region, language, seniority/tier)
+13. NEXT STEPS / OPEN QUESTIONS / FOLLOW-UPS
+14. PARTNER-FACING BRIEF — a 2-4 sentence narrative a partner can skim to decide yes/no,
+ drawn only from PART A
+
+== PART B — APPENDIX (not deal-specific) ==
+
+15. PRODUCT / WEBSITE / GTM FEEDBACK — feedback on the product, pricing page, website
+ wording, onboarding, or trial; capture even if off-topic for qualification
+16. TERMINOLOGY / DOMAIN-LANGUAGE NOTES — words that mean different things to each side or
+ carry domain-specific meaning (e.g. "partner", "donor", jargon)
+17. KEY VERBATIM QUOTES — 3-8 direct quotes that capture intent, needs, or objections
+```
+
+Print it, then save it to the lead folder as `YYYY-MM-DD-<lead>-call-summary.md`.
+
+**Stop here if the user only wanted the summary.** Ask before continuing to Step 3: a lead
+that is clearly not partner-shaped (section 12 says no) does not need a partner brief.
+
+---
+
+## Step 3 — The partner brief
+
+**The doctrine lives in `design-doc-doctrine.md` in this folder: what to produce, the
+structure, the rules, the verification, the self-check. Read it and follow it.** The rest of
+this section is only the mechanics.
+
+Default output is a **zero-inference partner brief**. Pass `--full` for the inference-enabled
+design doc. The doctrine defines both.
+
+1. **Gather** — read every source material in full, not just the summary. Convert a `.docx`
+ with `textutil -convert txt "<file>" -output /tmp/out.txt` on macOS.
+2. **Extract, grounded** — facts vs inferences, per the doctrine.
+3. **Draft** in the doctrine's section structure.
+4. **Verify load-bearing claims live** — WebFetch against the doctrine's doc map before
+ asserting any capability. Build the References appendix as you go.
+5. **Reconcile discrepancies** — sources that disagree (call vs braindump, a name differing
+ across sources) get flagged both ways, never silently resolved.
+6. **Resolve ❓ with the operator** — after a full v1 draft, use AskUserQuestion for the
+ unknowns a Twenty insider can answer. Leave customer-facing unknowns as ❓. **Running
+ autonomously** (a subagent or batch run) means skipping the questions and leaving every
+ unknown as ❓.
+7. **Run the doctrine's self-check**, fix, then save as `YYYY-MM-DD-<lead>-partner-brief.md`
+ (or `-design-doc.md` in `--full`).
+
+---
+
+## Step 4 — Publish the brief as a Google Doc
+
+The partner gets a link, never an attachment: a Gmail compose URL cannot carry a file, and a
+`.md` attachment is a poor read.
+
+1. Open the shared Drive folder in Chrome:
+
+```bash
+open -a "Google Chrome" "https://drive.google.com/drive/folders/1ISDCplqLv6GrBQOOX7Fk4OK07LAK8BPd"
+```
+
+2. Tell the user: create the Doc there, paste the brief markdown, then paste the share URL
+ back. Mention `Tools → Preferences → Enable Markdown` once, so the paste renders headings,
+ bold and tables instead of showing raw `##`.
+
+3. **Wait for the URL.** If the user skips it, carry on with Step 5 and leave `designDocUrl`
+ empty. Say so, because `twenty-partner-intro` will then have no link to send.
+
+The folder is shared `anyone with the link can view`, so a partner can open it without an
+account. Do not call the Drive API: the connected account is personal, and any Doc it created
+would land in the wrong Drive under the wrong owner.
+
+---
+
+## Step 5 — Write `partner-match-criteria.md`
+
+Always, as a third file in the lead folder. This is the input `twenty-partner-shortlist`
+reads.
+
+- **Hard requirements** — a `Criterion | Why` table. Cover language and region, deployment
+ type, data-model complexity signal, migration capability, engagement model (fixed vs
+ retainer).
+- **Strong preference** — bullets: domain familiarity, migration experience, willingness to
+ scope for free, ability to work with non-technical end-users.
+- **Nice to have** — bullets: industry-specific workflow experience, partner size fit.
+- **Red flags** — bullets: anything that would disqualify a partner silently (language,
+ hosting model, engagement type, technical depth).
+- **Budget** — what the client said about money, verbatim, or "not stated". Most calls never
+ state a ceiling, and that is itself the answer. `twenty-partner-shortlist` shows this next
+ to each partner's rate; it never filters on it.
+- **Matching notes** — 3 to 5 bullets: technical nuances, the prospect's sophistication
+ level, migration unknowns, who the decision-makers are. Draw from Open questions and
+ Implementation complexity.
+
+---
+
+## Step 6 — Record the Opportunity
+
+**This step writes to production.** Search before creating, always.
+
+1. **Search** for an existing Opportunity on the company name (see the shared reference). If
+ one comes back, show it to the user and ask whether to update it or create a new one.
+ Never create a silent duplicate.
+2. **Resolve the company and the point of contact**: search first, create only on a miss.
+3. **Create** the Opportunity:
+
+| Field | Value |
+|---|---|
+| `name` | `<Company> <need in about three words>`, matching existing records: `TADA new CRM`, `Aranya CRM Migration`, `ECF PRO - Self-hosting multi-workspace` |
+| `stage` | `NEW` |
+| `need` | one line, from section 6 of the summary |
+| `requirements` | the requirements text, from section 7 |
+| `companyId`, `pointOfContactId` | resolved above |
+| `designDocUrl` | `{ "primaryLinkUrl": "<the Doc URL>", "primaryLinkLabel": "Partner brief" }`, omitted if Step 4 produced no URL |
+
+Do **not** set `isListed`: that belongs to the marketplace pull flow, which this path does
+not use. Do **not** set `introSentAt` and do not create any Application:
+`twenty-partner-intro` owns both.
+
+4. **Verify** by reading the record back, then print its id and name.
+
+---
+
+## Output files
+
+In the lead folder:
+
+- `YYYY-MM-DD-<lead>-call-summary.md`
+- `YYYY-MM-DD-<lead>-partner-brief.md` (or `-design-doc.md` in `--full`)
+- `partner-match-criteria.md`
+
+---
+
+## Notes
+
+- Keep `partner-match-criteria.md` current as you learn more about the lead. It feeds
+ `twenty-partner-shortlist` and, eventually, in-product matching logic.
+- Sections 7 and 12 of the summary are the matching axes: `Deployment → deploymentExpertise`,
+ scope needs → `partnerScope`, region and language → partner region and languages, scale →
+ capacity, the "needs a partner?" tier → `partnerTier`.
+- Worked example: `partners-experience/TSF/2026-05-26-tsf-design-doc.md` shows the target
+ coverage, flag discipline and verification appendix. It predates the current concision and
+ formatting rules, so **follow the doctrine over the example** where they differ.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-lead-brief/design-doc-doctrine.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-lead-brief/design-doc-doctrine.md
new file mode 100644
index 00000000000..aec4721440c
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-lead-brief/design-doc-doctrine.md
@@ -0,0 +1,361 @@
+# Design-doc doctrine: translating a lead into Twenty terms
+
+**Portable doctrine.** Tool-agnostic. It defines *what* a Twenty partner design doc is, its
+structure, the rules, and how to verify it. Two consumers use it: the Claude Code skill
+`twenty-lead-brief` (see `SKILL.md` in this folder), and, in a later phase, the `content` of
+a Twenty `defineSkill` driving an in-product agent. Keep it free of any one tool's mechanics
+(no file paths, no tool names).
+
+Every rule lives here **once**. To restate one elsewhere, link to it instead.
+
+## Purpose
+
+Produce a doc that translates a qualified lead's needs into **Twenty terms** (data model,
+permissions, integrations, hosting, plus whatever else the client named) so an
+implementation **partner can scope and quote** the work.
+
+**Core principle:** identify *all* the work with **no blindspots**, **ground every claim** in
+the source or in live Twenty docs, and **present options rather than prescribe**. The partner
+quotes off this doc, so a confident-but-wrong capability claim or a hidden requirement is the
+worst failure.
+
+**Stay on the client's outcome.** Every line must change what the partner *builds* or what
+the client *receives*. The doc is a design, not a meeting record.
+
+The doc is **partner-facing** and may be forwarded verbatim. It is a *suggestion to make
+scoping easier*, not a spec that constrains how the partner builds.
+
+## Output structure
+
+**Header: a compact table, four fields only.** Never a stack of bold lines.
+
+| Field | Value |
+|---|---|
+| Lead | name (one-line description of who they are) |
+| Date | YYYY-MM-DD |
+| Author | Twenty (partnerships) |
+| Status | one short line (e.g. "Draft for partner review") |
+
+Keep the Status line short: a load-bearing caveat (e.g. "data model is an inference pending
+discovery") goes in the "What this is" callout, not in the header cell. Never list source
+materials, internal timelines, or who-promised-what: not load-bearing, not customer-safe.
+
+After the table, one **"What this is"** callout framing the doc as a partner-scoping
+suggestion across the full surface, *not* an MVP.
+
+### Flags
+
+Emoji **and** short text label, always together, so they are scannable and unambiguous:
+
+- **❓ open** open question to resolve before quoting.
+- **⚠️ heavy** product-constrained, needs special design, or has a real cost.
+- **🛑 blocker** dealbreaker-grade. Doesn't quote without resolution.
+
+These three only. Never invent a flag, swap the emoji (🟥 / 🚩 / 🚨 / ✅), or drop the text
+label. `--full` mode adds a fourth, `🔮 inf.`.
+
+### Required sections
+
+Number sequentially, no gaps. A doc with Context, Data model, Integrations, Permissions,
+Hosting, Phasing, Open questions, References is §1 through §8.
+
+**Context** — the 30-second read: who they are, what they want, deployment requirement,
+scale, language and region.
+
+**Data model in Twenty terms** — the core. A **table, one row per object**:
+`Object | Std/Custom | Represents | Key fields | Core relations`. Only objects the client
+explicitly named; only fields the client explicitly named; `—` for an empty cell. Spell out
+SELECT option sets.
+
+**Model the relationships, not just the fields.** Who introduced or sourced a record (an
+ambassador to Opportunity `sourcedBy`), parent and child, ownership: these carry as much
+scoping signal as the attributes. A data-model section written as prose, or one that lists
+fields but no links, has missed the point.
+
+State product constraints **only when they change the build or the quote**, and inline: no
+formula fields, so reporting ratios need a logic-function-maintained stored field; custom
+objects auto-get attachments, notes, tasks and timeline, so relationship tracking is free.
+
+Where a customer term collides with a Twenty term (their "partner" is a donor), note the
+mapping inline as a small "term collisions" bullet list above the table. Never add a glossary
+section.
+
+**Roles, permissions & RLS** — map named roles to Twenty's object, field and row-level model.
+Answer "do we need RLS?" against verified, plan-gated capability.
+
+**Hosting & compliance** — cloud vs self-host, data-residency requirement (verify), GDPR.
+Flag contradictions.
+
+**Suggested phasing** — layers, labelled "(the partner's call, not Twenty's)".
+
+**Open questions / blindspot-killers** — the list a partner must resolve before pricing.
+**The one exception to "tables over bullets": always a numbered list**, so the partner can
+speak them as items 1, 2, 3 with the client. Each item names the decision it gates and links
+back to its body section.
+
+**References & verification** — a `Claim (§) | Verified against` table, then an explicit
+"**Could not be confirmed in public docs (check with Twenty directly):**" list. Cite the
+**human-readable (non-`.md`) URL**: the `.md` twin is for your fetch, and renders as raw
+markdown in a partner's browser.
+
+### Conditional sections
+
+If the client didn't name the topic, **omit the section entirely**. Never include a section
+to say "X was not named": that is filler. Unknowns belong in Open questions.
+
+**Views & navigation** — include when the data model has enough scope to warrant a surface
+conversation. A **tight table**, columns `Surface | Shows | Audience`, one row per surface
+the workspace should expose day-to-day. **No `Type` column**: table vs kanban vs page layout
+is the partner's call, not a scoping decision. If the client named pipelines or layouts,
+capture them in `Shows`. Never render this as a bullet list. Supplement with a single
+follow-up bullet only when a cross-cutting open question needs flagging.
+
+**Automations** — only if the client named processes to automate. Give
+Workflow-or-logic-function for each; name the automation and its trigger.
+
+**Integrations** — only when the client explicitly names an external system (Gmail, Slack,
+WhatsApp). Direction, indicative mechanism, data flow, risks. A likely integration the client
+never named is a single **❓ open**, not a section.
+
+**Reporting & analytics** — only if the client named reporting needs. Map to native
+Dashboards; flag gaps with paths.
+
+Scale each section to its content. **Coverage of surface area matters more than depth per
+item.**
+
+## Default behavior: zero inference
+
+The default output is a **zero-inference partner brief**: sharp, small, strictly grounded.
+
+- **Nothing is inferred.** If the client didn't say it, it doesn't appear.
+- **Required sections with no grounded content** get exactly one line:
+ `> ⬜ Not discussed on call — needs input before this section can be filled.`
+- **Conditional sections** with nothing grounded are omitted entirely. The placeholder is for
+ required sections only.
+- **Data-model cells** with no grounded content get `—`, never an invented value.
+- **No `Source` column** in the data-model table: every row is `client`, so the column is
+ noise.
+- **`🔮 inf.` never appears.** If you want to use it, that line should not exist.
+- **Target length: 1 page.** Each section 1 to 5 lines.
+- **Verification** runs only for sections with grounded content.
+- Filename: `YYYY-MM-DD-<lead>-partner-brief.md`.
+
+## Full mode (`--full`)
+
+Use when discovery is complete, the lead is well documented, and inferences give the partner
+a richer starting model.
+
+| Dimension | Default | `--full` |
+|---|---|---|
+| Inferences | never | allowed, tagged `🔮 inf.` |
+| Empty section | placeholder line | filled with tagged inferences |
+| Data-model `Source` column | omitted | `client` / `inf.` |
+| Inferred field names and relations | not included | tagged `🔮 inf.` |
+| Length | 1 page target | as long as content requires |
+| Verification | grounded sections only | all load-bearing claims |
+| Filename | `…-partner-brief.md` | `…-design-doc.md` |
+
+## Rules
+
+Each rule states what to do and the failure it prevents.
+
+**Be concise: maximum signal per word.** Cut throat-clearing, scene-setting, hedges and
+feature-tour prose. Length is not coverage: a short doc that names every requirement beats a
+long one that pads each. A hesitant buyer reads a focused doc; a bloated one reads as cost.
+
+**Bullets and tables over paragraphs.** Reach for a table whenever rows share structure
+(objects, views, plans, paths). Use prose only for a nuance no bullet or cell can carry. The
+Open questions numbered list is the single deliberate exception.
+
+**Business decisions over technical mechanics.** Scope is what the partner *builds* and what
+the client *receives*: data sensitivity, who-sees-what, plan choice, hosting choice,
+integration surface, cost drivers. Cut SDK, runtime and build-tool internals that don't move
+the quote: Docker version, OAuth flavour, auto-system relations, env-var names, CI/CD
+workflow detail. The partner reads References for those.
+
+**Scope altitude: name the decision, defer the mechanics.** State the *decision* and its
+*cost or scope consequence*; leave implementation detail to the technical phase. "Production
+automations need a sandboxed serverless logic-function backend, an infra cost that belongs in
+the platform workstream" carries the quote signal. The exact `LOGIC_FUNCTION_TYPE` /
+`LAMBDA` / region / role / key settings do not. Deep mechanics inflate length and date fast.
+
+**Ground everything; tag inferences; never grow scope.** The partner quotes off this, so an
+invented field or requirement inflates the quote or sets a false expectation. If the
+*concept* is from the source but the *field name* is yours, that is an inference: tag it.
+Values lifted from the source (the customer's own category list becoming SELECT options) are
+grounded; only names you coin are inferences.
+
+**Record the design consequence, not the backstory.** State a requirement and the client's
+path that follows. Do not litigate *why* it is true. When a requirement traces to
+vendor-internal or third-party detail (corporate structure, legal domicile, ownership,
+internal commercial arrangements, who-confirms-what-with-whom), keep only the consequence: it
+is a commercial matter, not a build input, however much airtime it got on the call. An open
+item the client is waiting on is recorded as the **decision it gates**, not as a narrative.
+
+**No "left out" or "not named" placeholders.** A bullet saying *"sessions and programmes left
+out on purpose"*, or a section saying *"no reporting was named"*, is filler. Cut it. To flag
+an absence, write it as an Open question that gates a specific decision. Otherwise, silence.
+
+**Never repeat yourself.** State each fact once, in its home section; elsewhere link to it.
+Open questions and References are deliberate roll-ups: give the pointer and the decision the
+item gates, not a re-explanation. Repetition is the main source of bloat, and two copies of a
+claim drift out of sync.
+
+**Cross-references are functional anchor links.** `[§N](#n-section-slug)`, never a bare `§N`.
+The slug follows GitHub auto-anchoring: lowercase, spaces to hyphens, punctuation dropped,
+`&` removed leaving a double hyphen. A partner skimming a bare `§7` sees a number with no way
+to jump.
+
+**Database discipline: reuse and extend standard objects.** Company, Person and Opportunity
+plus built-in Notes, Tasks and Timeline cover most CRM needs; every new object multiplies
+build and maintenance. **A human actor is a Person with a role flag before it is a new
+object**: create an object only when it needs its own pipeline or reporting. Name the wall
+when you add one.
+
+**When the brief is thin, under-reach.** A blurry situation (no discovery call, sparse notes)
+is a reason to model the *fewest, most certain* objects and leave the rest as **❓ open**, not
+to compensate with an elaborate inferred domain. An over-detailed inference reads as scope
+and cost the customer never asked for, and scares a hesitant buyer off. Lead with standard
+objects plus the one or two custom objects the domain unmistakably needs. Say plainly, up
+front, that the model is a minimal starting sketch to validate.
+
+**Present build approaches; don't prescribe.** An automation can be a no-code Workflow *or* a
+logic function in an app: say both. Prescribing one penalizes a partner who would do the
+other. The doc identifies the *need*, not the *build*.
+
+**Every problem carries a path.** If you flag a constraint (dashboards can't share
+externally), pair it with at least one solution (CSV export, a front-component, a public site
+on the API) or a question that resolves it. A flag with no path is useless to someone pricing
+the work.
+
+**Flag what an approach can't satisfy.** The doc's value is surfacing walls and limits per
+requirement so the partner prices around them, not picking the one true solution.
+
+**Partner-facing voice.** Say **"Twenty," never first person** ("we", "our", "ours"). No
+local file paths: cite shareable `docs.twenty.com` URLs only. Customer quotes containing
+"we" or "our" are fine: they are quotes.
+
+**No characterisations or asides.** The doc is customer-forwardable, so keep out the source
+chat's off-hand remarks: characterisations of the buyer (budget, temperament,
+sophistication), named comparisons to competing vendors, and internal partnerships notes
+(deadlines, who promised what). If price-sensitivity or a competitor displacement genuinely
+shapes the build, state it neutrally as a requirement, never as a quote or a judgement.
+
+**Verify before asserting capability.** Any "Twenty can, can't, has or lacks X" that moves
+the quote must be verified live. **Undocumented is not impossible.** See Verification.
+
+### Formatting
+
+- One line per paragraph. **No mid-sentence hard wraps**: they render as broken lines.
+- **Never an em dash** (the long dash). Restructure, or use a colon, comma, parentheses, or a
+ period.
+- **Never a bare `~`** for "approximately": GitHub markdown pairs `~…~` into strikethrough.
+ Write "around" or "about".
+- Mark unverified capability claims **❓ open**, never as fact.
+
+## Verification
+
+Any statement of the form **"Twenty can, can't, has or lacks X"** that changes the partner's
+quote MUST be verified **live** before it is stated as fact. Model training is stale on a
+fast-moving product; the worst failure is a confident, authoritative-sounding claim that is
+wrong.
+
+**Source hierarchy:**
+
+1. **Live docs** (`docs.twenty.com`): primary truth. For the highest-stakes claims, read the
+ page's primary text rather than trust a summary.
+2. **Established Twenty SDK build patterns** (hands-on): build-level facts the customer docs
+ omit (no formula fields; custom objects auto-get attachments, notes, tasks and timeline;
+ two-file relations).
+3. **The Twenty operator** (a Twenty team member): best for "is it shipped, internal, or
+ undocumented".
+4. **Model training**: never the sole basis for a high-stakes claim.
+
+**Right doc layer (the trap).** Capabilities live in two layers, so check the right one.
+
+- **Product capabilities** (what the CRM does for the *customer*): the **user guide and
+ pricing page**. Covers roles, row-level permissions, dashboards, plans, hosting, data
+ residency.
+- **App capabilities** (what an *app* can define): the **developer and extend** docs. Covers
+ field types, fields, logic functions, views, page layouts.
+
+Checking only the app layer is how "row-level not supported" (wrong) happens: row-level is a
+**product feature on the Organization plan**. The converse also holds: SDK build patterns
+*are* sufficient to assert **build-layer** facts even when the customer docs are silent, so
+do not demote a well-established build fact to **❓ open**.
+
+Two claims are stale in model training and must always be checked: "Twenty isn't a BI tool"
+(it has Dashboards) and "Twenty can't do row-level" (Organization plan).
+
+**Always verify, live, every run:**
+
+1. Field types and constraints (no formula or computed fields).
+2. Standard-object extension and relabeling (add fields; relabel built-in SELECT options?).
+3. Roles and permissions: object, field and row-level, and which plan tier gates them.
+4. Dashboards and reporting: chart and widget types, beta status, export and
+ external-sharing limits.
+5. Automation surfaces: Workflows vs logic functions, what each can do.
+6. Integration mechanisms: webhooks, HTTP triggers, scheduled functions, connections.
+7. Hosting and deployment: cloud plans and regions, **EU data residency**, self-host
+ availability and requirements.
+
+Plus any other capability claim the draft makes that carries a **⚠️ heavy** or **❓ open**.
+
+**Fallback chain:**
+
+- Docs confirm the claim, so state it as fact and record the source in References.
+- Docs are silent or ambiguous, so ask the operator, if one is available.
+- The operator is unavailable or unsure, so render it as **❓ open**. **Never assert.** When
+ you fetched a page and it was simply silent, record "docs silent (URL)" rather than leaving
+ the claim unsourced.
+
+**Doc map.** Base `https://docs.twenty.com/`. Fetch **`<path>.md`** for the clean markdown
+twin.
+
+- Product and user-guide: `user-guide/dashboards/overview` ·
+ `user-guide/dashboards/capabilities/widgets` ·
+ `user-guide/permissions-access/how-tos/permissions-faq` · `user-guide/data-model/overview` ·
+ `user-guide/data-model/capabilities/fields` ·
+ `user-guide/data-migration/how-tos/export-your-data`
+- Developer and extend: `developers/extend/apps/data/objects` ·
+ `developers/extend/apps/data/extending-objects` · `developers/extend/apps/data/relations` ·
+ `developers/extend/apps/logic/logic-functions` ·
+ `developers/extend/apps/logic/connections` · `developers/extend/apps/layout/views` ·
+ `developers/extend/apps/layout/page-layouts` · `developers/extend/apps/config/roles`
+- Self-host: `developers/self-host/self-host`
+- Pricing and plans: `https://twenty.com/pricing` (**marketing page, no `.md`**, fetch as
+ HTML).
+
+If a `.md` 404s, drop the suffix or re-derive from the docs index: the map can go stale.
+
+## Self-check
+
+Run this list against the finished draft. Every item restates a rule above; this is the
+scannable form, not a new rule set.
+
+**Hard failures, fix before saving:**
+
+- [ ] An em dash anywhere.
+- [ ] A bare `~` for "approximately".
+- [ ] First-person voice ("we", "our") outside a customer quote.
+- [ ] A local file path.
+- [ ] A header that is not the four-field table.
+- [ ] A flag that is not `**❓ open**`, `**⚠️ heavy**` or `**🛑 blocker**` (plus `🔮 inf.` in
+ `--full`). A stray 🟥 🚩 🚨 ✅, or a naked emoji with no text label, is wrong.
+- [ ] `🔮 inf.` present in default mode. Remove the whole inference, not just the tag.
+- [ ] A `Source` column in the data-model table in default mode.
+- [ ] A section that just says "X was not named", or lists what was left out on purpose.
+- [ ] A bare `§N` instead of `[§N](#n-section-slug)`.
+- [ ] Renumbering gaps: a section was cut but the numbers around it were kept.
+- [ ] A capability claim stated as fact with no References source.
+
+**Warnings, fix unless you can justify it:**
+
+- [ ] A section that is mostly paragraphs where bullets or a table would do. Open questions
+ is the exception.
+- [ ] Build, runtime or SDK mechanics that don't change the quote.
+- [ ] A point repeated across sections instead of a `[§N](…)` cross-reference.
+- [ ] A leftover glossary or domain-language section.
+- [ ] A Views table with a `Type` column, or Views rendered as a bullet list.
+- [ ] An Integrations section for a system the client never named.
+- [ ] Doc longer than 2 pages in default mode.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-lead-intro-call-summary/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-lead-intro-call-summary/SKILL.md
deleted file mode 100644
index 16eff4f9f2f..00000000000
--- a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-lead-intro-call-summary/SKILL.md
+++ /dev/null
@@ -1,116 +0,0 @@
----
-name: twenty-lead-intro-call-summary
-description: Turn a sales/discovery-call transcript into a faithful, structured qualification brief for Twenty's partner/CRM pipeline. Use this whenever the user has a call recording or transcript — including a meetily recordings folder or a transcripts.json — and wants to summarize, recap, qualify, or extract a brief from a prospect/discovery call. Trigger even when they don't say "brief": phrases like "summarize this call", "what did we learn from the X call", "qualify this lead from the call", "turn this transcript into something I can hand a partner", or pointing at a transcript file all count. Produces a tight deal one-pager (company, needs, implementation complexity, does-it-need-a-partner, partner-facing brief) plus an appendix (product/GTM feedback, terminology, quotes). It is a faithful extraction, not a lossy summary.
-trigger: /twenty-lead-intro-call-summary
----
-
-# twenty-lead-intro-call-summary
-
-Turn a discovery/sales-call transcript into a **qualification brief** that (a) loses no
-decision-relevant detail and (b) can be used to qualify the deal and hand it to an
-implementation partner. Designed for Twenty's partner/CRM pipeline, tuned for messy,
-label-less ASR transcripts (e.g. meetily exports).
-
-The output is two parts: a tight **Part A deal one-pager** (everything the deal/partner
-work needs) and a **Part B appendix** (not deal-specific: product feedback, terminology,
-quotes). The structure is what prevents loss — a "summary that loses nothing" is a
-contradiction, so this is a *structured extraction* against a fixed schema where every
-dimension has a slot and gaps are marked rather than silently dropped.
-
-## Step 1 — Get the transcript
-
-The transcript is provided by the user — usually pasted text, or a path they point you at
-(a `.txt`/`.vtt`/`.srt`, or a meetily recording folder / `transcripts.json`). If they give a
-path, read it: a meetily `transcripts.json` is `{ "segments": [ { "text": ... } ] }` —
-concatenate the `text` values in order; for `.vtt`/`.srt`, drop the cue numbers and
-timecodes.
-
-**If no transcript is provided, ask for it before doing anything else.** Don't fabricate or
-proceed without one.
-
-For very long transcripts, read the whole thing before writing — coverage is the point.
-
-## Step 2 — Produce the brief
-
-Follow these rules and fill this exact schema. Why each rule matters is noted, because
-faithful extraction depends on judgment, not rote form-filling.
-
-**Rules**
-- Extract ONLY what is in the transcript. Never invent or assume. If a field isn't covered,
- write "Not discussed." (Visible gaps beat confident fabrication — a missing field is a
- signal to ask on the next call.)
-- Separate stated FACTS from your INFERENCES; mark any inference "(inferred)". (Downstream
- matching trusts the facts; don't contaminate them with guesses.)
-- Preserve specifics verbatim: numbers, dates, names + roles, tool/CRM names, prices,
- budgets, exact requirements. Don't round or paraphrase numbers. (Specifics are where
- nuance and matching signal live; paraphrase kills them.)
-- Use the customer's own words for needs and objections; quote pivotal lines.
-- Don't smooth over contradictions or vagueness — note them. (A flagged contradiction is
- more useful than a falsely tidy summary.)
-- If the transcript has NO speaker labels, infer from context who is the vendor (Twenty)
- and who is the prospect, and attribute accordingly. Names get garbled by speech-to-text —
- flag any uncertain name with "(uncertain)" and never invent a name.
-- Keep PART A tight — it's the one-pager the deal/partner work runs on. Push everything not
- specific to this deal (product/website feedback, terminology, supporting quotes) to
- PART B. State each fact once; never repeat it across sections.
-
-**Output (use these exact headers)**
-
-```
-== PART A — DEAL ONE-PAGER ==
-
-1. ONE-LINE SUMMARY
-2. COMPANY — name, what they do, size/employees, HQ + countries of operation, industry
-3. PEOPLE ON THE CALL — name, role/title, side (Twenty vs prospect); infer roles if
- unlabeled and flag uncertain names
-4. CURRENT SITUATION — what CRM/tools they use today; specific pains
-5. WHY THEY'RE INTERESTED IN TWENTY
-6. WHAT THEY WANT — bulleted needs/requirements, verbatim where possible
-7. IMPLEMENTATION COMPLEXITY (for partner matching)
- - Deployment: cloud / self-host / both / unclear (+ the evidence)
- - Data model: custom objects, multi-tenant, row-level security, migrations
- - Integrations / custom apps needed
- - Workflows / automation needs
- - Scale: number of seats/users
- - Region + language the partner would need to cover
-8. COMMERCIALS — budget or prices discussed, plan tier (Pro/Org/Enterprise), seat count,
- deal value, who pays
-9. TIMELINE & DECISION — key dates, decision-makers, urgency, decision process
-10. OBJECTIONS / RISKS / FEARS — including anything that could kill the deal
-11. ALTERNATIVES — competitors or other options they're weighing
-12. DOES THIS DEAL NEED A PARTNER? — yes / no / maybe + why; and if yes, what kind
- (scope, region, language, seniority/tier)
-13. NEXT STEPS / OPEN QUESTIONS / FOLLOW-UPS
-14. PARTNER-FACING BRIEF — a 2-4 sentence narrative a partner can skim to decide yes/no,
- drawn only from PART A
-
-== PART B — APPENDIX (not deal-specific) ==
-
-15. PRODUCT / WEBSITE / GTM FEEDBACK — any feedback on the product, pricing page, website
- wording, onboarding, or trial; capture even if off-topic for qualification
-16. TERMINOLOGY / DOMAIN-LANGUAGE NOTES — words used on the call that mean different things
- to each side or carry domain-specific meaning (e.g. "partner", "donor", jargon)
-17. KEY VERBATIM QUOTES — 3-8 direct quotes that capture intent, needs, or objections
-```
-
-## Step 3 — Output and save
-
-Print the brief in the conversation. Then offer to save it as Markdown — default to a
-sibling of the source (e.g. next to the recording) or, for Twenty work, the
-`partners-experience/research/` folder, named `YYYY-MM-DD-<company>-call-summary.md`. Don't
-write the file unless the user wants it saved.
-
-## How the fields map to the Partner model (for matching)
-
-Section 7 + 12 are the matching axes: `Deployment → deploymentExpertise`, the scope needs →
-`partnerScope`, `Region + language` → partner region/languages, scale → capacity, the
-"needs a partner?" tier → `partnerTier`. Keeping these explicit is what lets the brief drop
-straight into the opportunity→partner handover flow.
-
-## Notes
-
-- This is tuned for Twenty discovery calls, but the schema generalizes — swap the vendor
- framing in section 5/12 if reused elsewhere.
-- The worked reference example lives at
- `partners-experience/research/2026-05-21-tsf-call-summary-final.md` (and the prompt alone
- at `partners-experience/research/call-summary-prompt.md`).
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-application-triage/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-application-triage/SKILL.md
deleted file mode 100644
index b41deef9ca0..00000000000
--- a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-application-triage/SKILL.md
+++ /dev/null
@@ -1,128 +0,0 @@
----
-name: twenty-partner-application-triage
-description: Rank the partner-application backlog by net-new value and surface a short chase-list of high-value applicants who haven't booked a call. Use when the user wants to triage, rank, or prioritize partner applications, find which applicants are worth chasing, run the daily/weekly application review, or asks "who should I reach out to" / "which applications matter". Reads the live partners workspace; read-only.
-trigger: /twenty-partner-application-triage
----
-
-# twenty-partner-application-triage
-
-Rank `APPLICATION`-stage partners by the value they would *add* — geographies and
-languages we don't yet cover, plus proof of real Twenty work — and hand back a short
-**chase-list**: the high-value applicants worth a personal nudge.
-
-**The door stays open for everyone.** This skill does not reject or filter anyone out of
-the pipeline. Booking a call is the motivation filter; this just makes sure the good
-applicants who *didn't* book bubble up so they don't rot. The point is a few high-confidence
-partners, not maximum coverage.
-
-Read-only. It never mutates a record.
-
----
-
-## Credentials
-
-Needs `~/.twenty/credentials.env` (same file the other partner skills use):
-
-```env
-TWENTY_PARTNERS_API_URL=https://partners.twenty.com
-TWENTY_PARTNERS_API_KEY=<your key>
-```
-
-The key lives in `packages/twenty-apps/internal/twenty-partners/.env.prod` (gitignored) —
-copy it to `~/.twenty/credentials.env` on first setup.
-
----
-
-## Phase 0 — Run the ranker
-
-```bash
-python3 "$(dirname "$0")/rank.py" # or: python3 rank.py from the skill dir
-```
-
-`rank.py` is the deterministic core. It pulls every partner, computes each applicant's
-net-new geo / language / scope / skills vs the **VALIDATED** baseline, detects a "real
-Twenty work" proof signal in the notes, scores, and prints ranked JSON. It does not call an
-LLM — the judgment lives in you (Phase 1).
-
-Each ranked entry: `name, score, tier (A/B/C), new_geo, new_lang, new_scope, new_skills,
-proof{workspace_url|customers|migration}, team, contact_name, email, linkedin, website,
-notes`.
-
-Scoring (in `rank.py`, tune there if it drifts): geo +3 each, language +3 each, scope +1,
-skills +1 capped at 3 (so generic dev shops that spray skill lists can't dominate), proof
-+6. Any proof signal ⇒ at least tier A.
-
-**Booking state:** if the JSON has `booking_state_wired: false`, the `callBookedAt` field
-isn't on the model yet, so the ranker scores **all** applications. Say so in the output.
-Once `callBookedAt` exists, the ranker auto-narrows to the un-booked (the true chase set) —
-no skill change needed.
-
-If the run prints a missing-credentials error, stop and tell the user exactly which key to
-add and where.
-
----
-
-## Phase 1 — Judgment pass (this is the point)
-
-The score surfaces; you decide. Read the `notes` of the **top ~15** plus anything tier-B/C
-with a non-trivial note, and adjust:
-
-- **Rescue the motivated-but-unobvious.** Someone whose checkboxes are thin but whose notes
- show real intent, a live Twenty instance, named customers, or a thoughtful pitch is a
- chase even at a low score. This is the whole reason a human/LLM reads the notes — the
- applicants who do things we don't see in the form are exactly who we don't want to lose.
-- **Sanity-check volume inflation.** A high score driven by 6 net-new *languages* from one
- solo, or a long skills list, may be aspirational. Confirm it against the notes before
- ranking it top. Real net-new geography with proof beats a long list every time.
-- **Demote noise.** Empty notes, agency spam, or "Tally submission: <id>" with nothing else
- is tier C regardless of score. Don't chase them.
-- **Note proof quality.** `workspace_url` + `customers` together (a live workspace with named
- clients) is the strongest signal — stronger than the raw score. Call it out.
-
-Don't invent facts. If a note is ambiguous, say so rather than upgrading on a guess.
-
----
-
-## Phase 2 — Output the chase-list
-
-A tight digest, grouped by tier, A first. Lead with the count and the booking-state caveat.
-
-```
-# Partner application triage — N applications ranked (booking state: not wired / un-booked only)
-
-## Chase now (Tier A — fills a gap AND/OR proven)
-- **<name>** (<team>) — +<geo>/<lang>; proof: <workspace+customers/…>
- why: <one line, drawn from notes>
- reach: <email> · <linkedin>
-
-## Worth a look (Tier B)
-- <name> — <one line>; reach: <email>
-
-## Skip for now (Tier C) — <count>, not listed (empty/spam/no gap)
-```
-
-Rules:
-- Tier A is the actual worklist. Keep it short — if it's 18 long, the proof-backed gap-fillers
- go first and the volume-only ones go last.
-- Always give a reach handle (email from `contact_name`/`email`, else linkedin, else website).
- If none, say "no contact on record" — that itself is a data-quality flag.
-- Be honest. If only a handful are genuinely worth chasing, say so; don't pad the A-tier.
-
----
-
-## What this is not
-
-- Not a gate. It never moves anyone to `REJECTED` or out of the funnel.
-- Not a writer. It never edits a record. Surfacing only.
-- Not the production cron. This is the **dev surface** for the ranking. Once the chase-list
- is trustworthy, the deterministic core (`rank.py`) is what gets ported to a daily
- logic-function cron in the partner app that writes `ranking` + a tier onto each un-booked
- record so the workspace view sorts itself. The LLM judgment pass stays here, for the runs
- where you want a human in the loop. Build skill → trust it → port the cheap part. Don't
- build both.
-
-## Self-check
-
-`python3 rank.py --selftest` asserts the scoring orders a gap-filler-with-proof above a
-skill-sprayer above an empty record, and that skill volume stays capped. Run it after any
-edit to the weights or signal regexes.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-design-doc/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-design-doc/SKILL.md
deleted file mode 100644
index 0eaa6815a25..00000000000
--- a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-design-doc/SKILL.md
+++ /dev/null
@@ -1,60 +0,0 @@
----
-name: twenty-partner-design-doc
-description: Use when turning a qualified Twenty lead — a call-summary brief plus any client braindump/docs — into a partner brief a partner can scope and quote from. Trigger when pointed at a lead folder (e.g. partners-experience/<LEAD>/) and asked to "draft a design doc", "create a partner brief", "translate this into Twenty terms", "scope this for a partner", or "prep the partner handoff". Default output is zero-inference (only what the client said; empty sections get a placeholder). Pass --full for inference mode. Chains after twenty-lead-intro-call-summary.
-trigger: /twenty-partner-design-doc
----
-
-# twenty-partner-design-doc
-
-Turn a qualified lead's materials into a **design doc**: a translation of the customer's needs into **Twenty terms** that an implementation **partner reads to scope and quote** the work.
-
-**The doctrine — what to produce, the 12-section structure, the rules, the verification process, and the common mistakes — lives in `design-doc-doctrine.md` in this folder. Read it and follow it.** This file is only the Claude Code wrapper: how to gather inputs, which tools to use for each step, and where to save.
-
-## Inputs
-
-- A lead folder (e.g. `partners-experience/<LEAD>/`) containing a `twenty-lead-intro-call-summary` output plus any braindump / docs / notes.
-- If there is a raw transcript but no brief, run **twenty-lead-intro-call-summary** first — this skill chains after it.
-- Read everything. Convert `.docx` with `textutil -convert txt "<file>" -output /tmp/out.txt` (macOS) or an equivalent extractor.
-
-## Default: zero-inference partner brief
-
-The default output is a **zero-inference partner brief**: only what the client explicitly said, nothing invented.
-
-- `🔮 inf.` **never appears.** If you feel the urge to use it, that line should not exist.
-- Required sections with no grounded content get: `> ⬜ Not discussed on call — needs input before this section can be filled.`
-- Data-model table: **no Source column**; only rows for objects the client named; only fields the client named; `—` for empty cells.
-- Target length: 1 page. Each section 1–5 lines max.
-- Step 2: extract stated facts only. Step 4: verify only sections with grounded content.
-- Step 7 self-check: `🔮 inf.` anywhere = failure (remove the whole inference); Source column = failure; doc >2 pages = warning.
-- Save as `YYYY-MM-DD-<lead>-partner-brief.md`.
-- See "Default behavior" in `design-doc-doctrine.md` for the full rules.
-
-## Mode: `--full` (inference-enabled design doc)
-
-Pass `--full` when discovery is complete and a richer inferred model is useful. Enables `🔮 inf.` tags, adds the Source column to the data model, fills gaps with inferences, and allows longer output. Save as `YYYY-MM-DD-<lead>-design-doc.md`. See "Full mode" in `design-doc-doctrine.md`.
-
-## Steps
-
-1. **Gather** — read all source materials in full. Coverage is the point.
-2. **Extract needs, grounded** — facts vs inferences (`(inf.)`); never invent. Per the doctrine.
-3. **Draft** the doc in the doctrine's 12-section structure, applying every rule in the doctrine.
-4. **Verify load-bearing claims live** — use **WebFetch** against the Twenty doc map in the doctrine's Verification section before asserting any capability. Build the §11 appendix as you go.
-5. **Reconcile discrepancies** — sources that disagree (call vs braindump; a name differing across/within sources) get flagged both ways, never silently resolved.
-6. **Resolve ❓ with the operator** — after a full v1 draft, use **AskUserQuestion** to ask the Twenty team member the unknowns a Twenty insider can answer; leave customer-facing unknowns as ❓. **If running autonomously** (no operator — a subagent/batch run), skip the questions and leave every unknown as ❓ in the body and §11.
-7. **Self-check, then save** — scan the output for: an em dash; a bare `~`; first-person voice outside customer quotes; local file paths; a header that isn't the four-field table; **any flag that isn't one of the three canonical emoji-and-text pairs** (`**❓ open**`, `**⚠️ heavy**`, `**🛑 blocker**`) — a stray 🟥, 🚩, 🚨, ✅, 🔮, or a naked emoji without its text label is wrong (in default mode `🔮 inf.` is a failure, not just a format issue; remove the whole inference); **a Data-model table that has a `Source` column** (default mode — remove it; only `--full` mode uses it); **a section that just says "X was not named" / "no automations named" / a "left out on purpose" list** — cut it, unknowns go in Open questions; **any bare `§N` reference** instead of a functional anchor link `[§N](#n-section-slug)`; **renumbering gaps** (e.g. cut a section but kept the old numbers around it); **a section that is mostly paragraphs where bullets or a table would do** — exception: Open questions stays a numbered list; **build / runtime / SDK mechanics that don't change the quote** (Docker version, OAuth flavour, auto-system relations, env-var names, CI/CD workflow detail); a point repeated across sections instead of a `[§N](...)` cross-reference; a leftover glossary / domain-language section; any capability claim stated as fact without a References source. Fix, then save to the lead folder as `YYYY-MM-DD-<lead>-partner-brief.md` (or `design-doc.md` in `--full` mode).
-8. **Write partner-match-criteria.md** — always, as a third artifact alongside the brief. Save as `partner-match-criteria.md` in the same lead folder. Structure:
- - **Hard requirements** — table: Criterion | Why. Include: language/region, deployment type, data model complexity signal, migration capability, engagement model (fixed vs retainer).
- - **Strong preference** — bullets: domain familiarity, migration experience, willingness to scope for free, ability to work with non-technical end-users.
- - **Nice to have** — bullets: industry-specific workflow experience, partner size fit.
- - **Red flags** — bullets: anything that would disqualify a partner silently (language, hosting model, engagement type, technical depth).
- - **What to send the partner** — numbered steps: which files to share, what to ask the partner to confirm, when to make the intro.
- - **Matching notes** — 3–5 bullets for the partnerships team: technical nuances, prospect's sophistication level, migration unknowns, who the decision-makers are. Draw from the Open questions and Implementation complexity sections of the brief.
-
-## Worked example
-
-Reference: `partners-experience/TSF/2026-05-26-tsf-design-doc.md` shows the target **coverage, flag discipline, and §11 verification appendix**. It predates the current concision / table-header / no-glossary / no-em-dash rules, so where its formatting differs, **follow this doctrine over the example.**
-
-## Notes
-
-- Chain: **twenty-lead-intro-call-summary → twenty-partner-design-doc**; the output feeds the opportunity→partner handover (`designDocStatus` / `designDocUrl`).
-- **Phase 2:** `design-doc-doctrine.md` is written to be portable. A future `defineSkill` in this app (a sibling `*.skill.ts` in `src/skills/`) would import it as its `content`, driving an in-product agent — with a verify logic-function tool replacing the WebFetch step, and a Workflow Action triggering it when sales toggles `partnerEligible`. Keep doctrine changes in that file so both the Claude Code skill and the `defineSkill` stay in sync.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-design-doc/design-doc-doctrine.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-design-doc/design-doc-doctrine.md
deleted file mode 100644
index 56cac94c5fe..00000000000
--- a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-design-doc/design-doc-doctrine.md
+++ /dev/null
@@ -1,199 +0,0 @@
-# Design-doc doctrine: translating a lead into Twenty terms
-
-**Portable doctrine.** This file is tool-agnostic. It defines *what* a Twenty partner design doc is, its structure, the rules, and how to verify it. Two consumers use it: the Claude Code skill `twenty-partner-design-doc` (see `SKILL.md` in this folder), and, in a later phase, the `content` of a Twenty `defineSkill` driving an in-product agent. Keep it free of any one tool's mechanics (no file paths, no tool names).
-
-## Purpose
-
-Produce a **design doc** that translates a qualified lead's needs into **Twenty terms** (data model, permissions, integrations, hosting, plus whatever else the client named) so an implementation **partner can scope and quote** the work.
-
-**Core principle:** identify *all* the work with **no blindspots**, **ground every claim** in the source or in live Twenty docs, and **present options rather than prescribe**. The partner quotes off this doc, so a confident-but-wrong capability claim or a hidden requirement is the worst failure.
-
-**Stay on the client's outcome.** Every line must change what the partner *builds* or what the client *receives*. The doc is a design, not a meeting record: a requirement's backstory (why the vendor or a third party does or doesn't satisfy it) is not a build input. Capture the **consequence**, cut the backstory.
-
-The doc is **partner-facing** and may be forwarded verbatim. It is a *suggestion to make scoping easier*, not a spec that constrains how the partner builds.
-
-## Output structure
-
-**Header: a compact table, not a stack of bold lines.** Four fields only:
-
-| Field | Value |
-|---|---|
-| Lead | name (one-line description of who they are) |
-| Date | YYYY-MM-DD |
-| Author | Twenty (partnerships) |
-| Status | one short line (e.g. "Draft for partner review") |
-
-Keep the header to those four fields. The Status line stays short: a load-bearing caveat (e.g. "data model is an inference pending discovery") goes in the "What this is" callout, not in the header cell. Do not list source materials, internal timelines, or who-promised-what: not load-bearing, not customer-safe (the doc is forwarded verbatim).
-
-After the table, one **"What this is"** callout framing the doc as a partner-scoping suggestion across the full surface, *not* an MVP.
-
-**Flag legend (emoji + short text label, used together so they're scannable and unambiguous):**
-
-- **❓ open** open question to resolve before quoting.
-- **⚠️ heavy** product-constrained or needs special design / has a real cost.
-- **🛑 blocker** dealbreaker-grade. Doesn't quote without resolution.
-
-Use these three pairings only by default. Don't invent new flags, swap the emoji (🟥 / 🚩 / 🚨 / ✅), or drop the text label and use the emoji alone. In `--full` mode a fourth flag is added: `🔮 inf.` — see Full mode section.
-
-### Required sections (always present)
-
-Number sequentially in the final doc, with no gaps:
-
-- **Context**: the 30-second read: who they are, what they want, deployment requirement, scale, language/region.
-- **Data model in Twenty terms**: the core. Present objects as a **table, one row per object**: `Object | Std/Custom | Represents | Key fields | Core relations`. Include only objects the client explicitly named; include only fields the client explicitly named. If a cell has no grounded content, write `—`. Spell out SELECT option sets. **Model the relationships, not just the fields**: who introduced/sourced a record (e.g. an ambassador to Opportunity `sourcedBy` link), parent/child, ownership carry as much scoping signal as the attributes. State product constraints **only when they change the build or quote**, and inline (no formula fields → reporting ratios need a logic-function-maintained stored field; custom objects auto-get attachments/notes/tasks/timeline → relationship tracking is free). Where a customer term collides with a Twenty term (their "partner" = a donor), note the mapping inline as a small "term collisions" bullet list above the table; do **not** add a glossary section for it. In `--full` mode, add a `Source` column (`client` / `inf.`) and tag inferred field names and relations `🔮 inf.`.
-- **Roles, permissions & RLS**: map named roles to Twenty's object / field / row-level model; answer "do we need RLS?" against verified, plan-gated capability.
-- **Hosting & compliance**: cloud vs self-host, data-residency requirement (verify), GDPR. Flag contradictions.
-- **Suggested phasing**: "(the partner's call, not Twenty's)" layers, labelled a suggestion.
-- **Open questions / blindspot-killers**: the list a partner must resolve before pricing. **This is the one explicit exception to "tables over bullets": always render as a numbered list**, so the partner can speak them as items 1, 2, 3 with the client. Each item names the decision the question gates and links back to the body section with a functional cross-ref.
-- **References & verification**: a table mapping each load-bearing claim to its source doc, plus an explicit list of what the docs could NOT confirm (the unresolved **❓ open** items).
-
-### Conditional sections (include only when grounded in client speech)
-
-If the client didn't name the topic, **omit the section entirely**. Do not include a section just to say "X was not named" — that's filler. Unknowns belong in Open questions, not in their own section.
-
-- **Views & navigation**: include when the data model has enough scope to warrant a surface conversation. Render as a **tight table** with columns `Surface | Shows | Audience`, one row per surface (an object or a filtered subset) the workspace should expose day-to-day. **Do not** add a `Type` column (table / kanban / page layout): the view type is the partner's call, not a scoping decision. If the client explicitly named pipelines or layouts, capture them in the `Shows` cell. Keep the table to the surfaces that genuinely matter; supplement with a one-line follow-up bullet only when an open question about a cross-cutting surface needs flagging (e.g. an unscoped admin view).
-- **Automations**: only if the client named processes to automate. Give Workflow-or-logic-function for each; name the automation and its trigger.
-- **Integrations**: only when the client explicitly names an external system to connect (Gmail, Slack, WhatsApp, etc.). Direction, indicative mechanism (not prescriptive), data flow, risks. If you spot a likely integration that wasn't named, raise it as a single **❓ open** in Open questions, not as a whole section.
-- **Reporting & analytics**: only if the client named reporting needs. Map them to native Dashboards; flag gaps with paths.
-
-Number whatever you include sequentially. A doc with Context, Data model, Integrations (Gmail named), Permissions, Hosting, Phasing, Open questions, References is §1 through §8. Don't leave gaps.
-
-Scale each section to its content. **Coverage of surface area matters more than depth per item.**
-
-## Default behavior: zero inference
-
-The default output is a **zero-inference partner brief**: sharp, small, and strictly grounded in what the client said.
-
-- **Nothing is inferred.** If the client didn't say it, it doesn't appear in the doc.
-- **Required sections with no grounded content** get exactly one placeholder line: `> ⬜ Not discussed on call — needs input before this section can be filled.`
-- **Conditional sections** (Automations, Integrations, Reporting, Views) with nothing grounded are **omitted entirely** — same rule as always; the placeholder applies only to required sections.
-- **Data-model table cells** with no grounded content get `—`, not an invented value.
-- **`🔮 inf.` never appears.** If you find yourself wanting to use it, that line should not exist in the doc.
-- **Target length:** 1 page. Each section is 1–5 lines max.
-- **Verification** is run only for sections that have grounded content — no need to verify empty sections.
-- **Save as** `YYYY-MM-DD-<lead>-partner-brief.md`.
-
-### Self-check (zero-inference additions)
-
-After the standard self-check:
-- `🔮 inf.` anywhere is a hard failure — remove the entire inference, not just the tag.
-- Source column in the data-model table is a failure — remove it.
-- Doc longer than 2 pages is a warning — cut until only grounded content remains.
-
-## Full mode (`--full`)
-
-Pass `--full` to produce a **full inference design doc** instead of the default zero-inference brief. Use when: discovery is complete, the lead is well-documented, and inferences are needed to give the partner a richer starting model.
-
-| Dimension | Default (zero-inference) | `--full` |
-|---|---|---|
-| Inferences | Never | Allowed; tagged `🔮 inf.` |
-| Empty section | Placeholder line | Fill with inferences + `🔮 inf.` tags |
-| Data-model Source column | Omitted | `client` / `inf.` |
-| Inferred field names / relations | Not included | Tagged `🔮 inf.` |
-| Length | 1 page target | As long as content requires |
-| Verification | Grounded sections only | All load-bearing claims |
-| Filename | `YYYY-MM-DD-<lead>-partner-brief.md` | `YYYY-MM-DD-<lead>-design-doc.md` |
-
-In `--full` mode the fourth canonical flag is active: `🔮 inf.` (modelling inference; yours; the partner should confirm with the client). Used inline, often, unbolded.
-
-## Rules (and why each matters)
-
-- **Be concise: maximum signal per word.** Say a lot in few words. Cut throat-clearing, scene-setting, hedges, and feature-tour prose; prefer a table or a tight clause to a paragraph. Length is not coverage: a short doc that names every requirement beats a long one that pads each. A hesitant buyer reads a focused doc; a bloated one reads as cost.
-- **Bullets and tables over paragraphs, with one exception.** Default to bullets; reach for a table whenever rows share structure (objects, views, plans, paths). Use prose only for a nuance no bullet or table cell can carry. The Open questions section is the deliberate exception: always a numbered list, so the partner can read item 1, 2, 3 aloud.
-- **Business decisions over technical mechanics.** Scope is what the partner *builds* and what the client *receives*: data sensitivity, who-sees-what, plan choice, hosting choice, integration surface, cost drivers. Cut SDK / runtime / build-tool internals that don't change the quote (Docker version, OAuth flavour, auto-system relations, env-var names, version-control workflow). The partner reads References for the docs that cover those.
-- **Grounded content only (default).** Every line in the doc must trace back to something the client said. If it wasn't stated, it doesn't appear — use the placeholder or `—` for empty cells. In `--full` mode, inferences are allowed and tagged `🔮 inf.`; the Data-model table gains a `Source` column (`client` / `inf.`) so the partner can see at a glance which lines to confirm with the client.
-- **Section cross-references are functional anchor links.** Every `§N` reference must be a markdown anchor link: `[§N](#n-section-slug)`. The slug follows GitHub Flavored Markdown auto-anchoring (lowercase; spaces → hyphens; punctuation dropped; `&` removed leaving a double hyphen). A bare `§N` is unreadable to a partner skimming the doc, who just sees numbers with no way to jump.
-- **No "left out" / "not named" placeholders.** The doc speaks only about content grounded in the source. A bullet that says *"sessions/programmes/schools left out on purpose"* or a section that says *"no reporting was named"* is filler: cut it. If you want to flag the absence, write it as a question in Open questions ("Are sessions/programmes first-class objects?") that gates a specific decision; otherwise, silence.
-- **Never repeat yourself.** State each fact, constraint, or claim once, in its home section; elsewhere link to it (functional `[§N](...)`) rather than restate. Open questions and References are deliberate roll-ups: there, give the pointer and the decision the item gates, not a re-explanation of the body. Repetition is the main source of bloat, and two copies of a claim drift out of sync.
-- **Scope altitude: name the decision, defer the mechanics.** A design doc scopes the work; it is not the technical implementation spec. State the *decision* and its *cost or scope consequence*; leave the implementation nitty-gritty (specific env-var names, runtime internals, isolation models, SDK function signatures) to the later technical phase. Example: "production automations need a sandboxed/serverless logic-function backend, an infra cost that belongs in the platform workstream" carries the quote signal; the exact `LOGIC_FUNCTION_TYPE` / `LAMBDA` / region/role/key settings do not belong in a scoping doc. Deep mechanics inflate length and date fast without changing the quote.
-- **Ground everything; tag inferences `🔮 inf.`; never grow scope.** The partner quotes off this, so an invented field or requirement inflates the quote or sets a false expectation. If the *concept* is from the source but the *field name* is yours, that is an inference: tag it. Values lifted from the source (the customer's own category list becoming SELECT options) are *grounded*; only names/fields you coin are inferences.
-- **Record the design consequence, not the backstory.** State a requirement and the **client's path** that follows from it; do not litigate *why* it's true. When a requirement traces to vendor-internal or third-party detail (corporate structure, legal domicile, ownership, internal commercial arrangements, who-confirms-what-with-whom), keep only the consequence: it is a commercial matter, not a build input, however much airtime it got on the call. An open item the client is waiting on is recorded as the **decision it gates** (a **❓ open** in Open questions), not as a narrative of the vendor's situation.
-- **Database discipline: reuse and extend standard objects; add a custom object only at a genuine wall.** Company / Person / Opportunity plus the built-in Notes / Tasks / Timeline cover most CRM needs; every new object multiplies build and maintenance. A **human actor is a Person with a role flag before it is a new object**: create an object only when it needs its own pipeline or reporting. Name the wall when you add one.
-- **When the brief is thin, under-reach the inferred model; don't fill the gap.** A blurry situation (no discovery call, sparse notes) is a reason to model the *fewest, most certain* objects and leave the rest as **❓ open** open questions, not to compensate with an elaborate inferred domain. An over-detailed inference reads as scope and cost the customer never asked for and can scare a hesitant buyer off. Lead with standard objects plus the one or two custom objects the domain unmistakably needs; everything else is a question to confirm, not a row in the table. Say plainly, up front, that the model is a minimal starting sketch to validate.
-- **Present build approaches; don't prescribe.** An automation can be a no-code Workflow *or* a logic function in an app: say both. Prescribing one penalizes a partner who would do the other. The doc identifies the *need*, not the *build*.
-- **Every problem carries a path; never a dead-end flag.** If you flag a constraint (e.g. dashboards can't share externally), pair it with at least one solution (CSV export, a front-component, a public site on the API) or a question that resolves it. A flag with no path is useless to someone pricing the work.
-- **Flag what an approach can't satisfy.** The doc's value is surfacing walls and limits per requirement so the partner prices around them, not picking the one true solution.
-- **Partner-facing voice.** Say **"Twenty," never first person** ("we / our / ours"). **No local file paths** in the output: cite shareable `docs.twenty.com` URLs only. (Customer quotes that contain "we/our" are fine: they are quotes.)
-- **No characterisations or asides; only requirements and capabilities.** The doc is customer-forwardable, so keep out the source chat's off-hand remarks: characterisations of the buyer (budget, temperament, sophistication), named comparisons to competing vendors, and internal partnerships notes (deadlines, who promised what). If price-sensitivity or a competitor displacement genuinely shapes the build, state it neutrally as a requirement (e.g. cost is a selection criterion), never as a quote or judgement.
-- **Verify before asserting capability.** Any "Twenty can / can't / has / lacks X" that moves the quote must be verified live (see Verification). **Undocumented ≠ impossible.**
-
-## Formatting
-
-- One line per paragraph: **no mid-sentence hard wraps** (they render as broken lines).
-- **Never use em dashes (the long dash).** Restructure the sentence, or use a colon, comma, parentheses, or a period instead.
-- **Never a bare `~`** for "approximately": GitHub markdown pairs `~...~` into strikethrough. Write "around" / "about".
-- **Flags in default mode: three emoji + text pairs** (`**❓ open**`, `**⚠️ heavy**`, `**🛑 blocker**`). In `--full` mode a fourth is added: `🔮 inf.`. Don't swap the emoji or drop the text label.
-- **Section cross-references are functional anchor links** (`[§N](#n-section-slug)`), never bare `§N`.
-- Mark unverified capability claims `**❓ open**`, never as fact.
-
-## Verification
-
-Any statement of the form **"Twenty can / can't / has / lacks X"** that changes the partner's quote MUST be verified **live** before it is stated as fact. Model training is stale on a fast-moving product; the worst failure is a confident, authoritative-sounding claim that is wrong.
-
-**Source hierarchy (what to trust, in order):**
-1. **Live docs** (`docs.twenty.com`): primary truth. For the highest-stakes claims, read the page's primary text rather than trust a summary.
-2. **Established Twenty SDK build patterns** (hands-on): build-level facts the customer docs omit (no formula fields; custom objects auto-get attachments/notes/tasks/timeline; two-file relations).
-3. **The Twenty operator** (a Twenty team member): best for "is it shipped / internal / undocumented."
-4. **Model training**: never the sole basis for a high-stakes claim.
-
-**Right doc layer (the trap):** capabilities live in two layers, so check the right one.
-- **Product capabilities** (what the CRM does for the *customer*): the **user guide + pricing page**. Covers roles / row-level permissions, dashboards, plans, hosting, data residency.
-- **App capabilities** (what an *app* can define): the **developer/extend** docs. Covers field types, fields, logic functions, views, page layouts.
-Checking only the app layer is how "row-level not supported" (wrong) happens: row-level is a **product feature on the Organization plan**. The converse also holds: SDK build patterns *are* sufficient to assert **build-layer** facts even when the customer docs are silent (e.g. auto system relations), so do not demote a well-established build fact to **❓ open**.
-
-**Always verify (the load-bearing checklist), live, every run:**
-1. Field types & constraints (e.g. no formula/computed fields).
-2. Standard-object extension & relabeling (add fields ✓; relabel / edit built-in SELECT options?).
-3. Roles & permissions: object / field / row-level, and plan-gating (which tier).
-4. Dashboards & reporting: chart/widget types, beta status, export / external-sharing limits.
-5. Automation surfaces: Workflows vs logic functions, what each can do.
-6. Integration mechanisms: webhooks, HTTP triggers, scheduled functions, connections.
-7. Hosting & deployment: cloud plans & regions / **EU data residency**, self-host availability & requirements.
-Plus: any other capability claim the draft makes that carries a **⚠️ heavy** or **❓ open** flag.
-
-**Fallback chain:**
-- Docs confirm → state it as fact; record the source in References.
-- Docs silent or ambiguous → ask the operator (if available).
-- Operator unavailable or unsure → render it as a **❓ open** open question. **Never assert.** When you fetched a page and it was simply *silent*, record that as "docs silent (URL)" rather than leaving the claim unsourced.
-
-**References appendix format:** a `Claim (§) | Verified against` table, then an explicit "**Could not be confirmed in public docs (check with Twenty directly):**" list. Unverified items stay **❓ open** in the body too, never silently promoted to fact. Cite the **human-readable (non-`.md`) URL** here: the `.md` twin is for *your* fetch, not for the partner (a `.md` link renders as raw markdown in a browser).
-
-**Where to verify (Twenty doc map):** docs base = `https://docs.twenty.com/`. Fetch **`<path>.md`** for the clean markdown twin (the form to prefer). Paths:
-- Product / user-guide: `user-guide/dashboards/overview` · `user-guide/dashboards/capabilities/widgets` · `user-guide/permissions-access/how-tos/permissions-faq` · `user-guide/data-model/overview` · `user-guide/data-model/capabilities/fields` · `user-guide/data-migration/how-tos/export-your-data`
-- Developer / extend: `developers/extend/apps/data/objects` · `developers/extend/apps/data/extending-objects` · `developers/extend/apps/data/relations` · `developers/extend/apps/logic/logic-functions` · `developers/extend/apps/logic/connections` · `developers/extend/apps/layout/views` · `developers/extend/apps/layout/page-layouts` · `developers/extend/apps/config/roles`
-- Self-host: `developers/self-host/self-host`
-- Pricing & plans: `https://twenty.com/pricing` (**marketing page, no `.md`**; fetch as HTML).
-If a `.md` 404s, drop the suffix or re-derive from the docs index: the map can go stale.
-
-## Common mistakes
-
-| Mistake | Reality / fix |
-|---|---|
-| "Twenty isn't a BI tool" / "can't do row-level" | Stale training. Twenty has Dashboards; row-level is on the Organization plan. **Verify live.** |
-| Checked only the app-SDK doc for a product capability | Row-level lives in the product/pricing layer. **Verify the right layer.** |
-| Added fields not in the source | Scope growth, wrong quote. Only include what the client explicitly named; leave the cell `—` otherwise. |
-| Made a human actor (e.g. ambassador) its own object by default | A human is a Person + role flag first; an object only if it needs its own pipeline/reporting. |
-| Flagged an automation as "Workflow" | Prescribes the build, penalizes app-builders. Present both. |
-| Flagged a limit with no fix | Dead-end flag. Pair every problem with a path. |
-| Spelled out runtime/env-var mechanics (`LOGIC_FUNCTION_TYPE` / `LAMBDA`, region/role/key, Docker version, OAuth flavour, CI/CD workflow detail) | Wrong altitude. Name the decision + its cost; defer the mechanics to the technical phase. |
-| Same point restated across sections | State it once in its home section; cross-reference with a functional `[§N](...)` link. |
-| Padded prose / feature-tour narration | Maximum signal per word. State the content; cut the scene-setting. |
-| Added a domain-language map / glossary section | Removed. Note a genuine term collision inline in Data model; no standalone glossary. |
-| First-person "not ours" in a partner doc | Say "Twenty." The doc is forwarded verbatim. |
-| Local file paths in the output | Mean nothing to a partner. Cite `docs.twenty.com` only. |
-| Data-model section as prose; fields modelled but not relationships | Use a per-object field **table**; model the links, not just attributes. |
-| Hard-wrapped mid-sentence / used `~` / used an em dash | Broken lines / accidental strikethrough / banned dash. One line per paragraph; "around" not `~`; colon or comma, never an em dash. |
-| Used an emoji other than the four canonical (🟥 / 🚩 / 🚨 / ✅), or used the emoji without the text label | Stick to `🔮 inf.`, `**❓ open**`, `**⚠️ heavy**`, `**🛑 blocker**`. The text label disambiguates. |
-| Section is mostly paragraphs | Default to bullets and tables; prose only when a nuance can't fit a list. Exception: Open questions stays a numbered list. |
-| Included build / runtime / SDK mechanics that don't move the quote | Wrong altitude. Business decisions, scope consequences, and References only; mechanics belong in the later technical phase. |
-| Data-model table has a Source column (default mode) | In the default zero-inference mode, the Source column is unnecessary noise — every row is `client`. Omit it; only add it in `--full` mode. |
-| Cross-references are bare `§N` instead of functional links | The partner sees disconnected numbers and can't navigate. Use `[§N](#n-section-slug)` everywhere. |
-| Included a section that just says "X was not named" / "no automations named" / a "left out on purpose" list | Cut the whole section / bullet. Unknowns go in Open questions; the doc speaks only about grounded content. |
-| Renumbered with gaps (e.g. cut Reporting but kept §5-§11 numbering as §5, §6, §8) | Renumber sequentially, no gaps. A partner doesn't know which sections were omitted. |
-| Views section prescribed the view type (table / kanban / page layout) | The partner picks the view type. List **what to surface** (objects, subsets, who they're for), not **how**. |
-| Views section rendered as a bullet list | Render as a `Surface \| Shows \| Audience` table; supplement with a follow-up bullet only for a cross-cutting open question. |
-| Wrote up the vendor's corporate status / legal domicile / ownership / sign-off | Backstory, not a build input. Record only the **consequence**: requirement → the client's path; gate the open item as **❓ open** in Open questions. |
-| Filled a thin brief with an elaborate inferred model | Over-reach scares a hesitant buyer with unrequested scope. Model the few certain objects; flag the rest as **❓ open**; say it's a minimal sketch. |
-| Added an Integrations section with connectors the customer never named | Integrations is conditional, not default. Omit it absent a named system; at most flag one **❓ open**. |
-| Kept buyer characterisations / competitor asides / internal timelines | Not customer-safe. State needs neutrally; cut the rest. |
-| Listed source materials / who-promised-what in the header, or stacked it as bold lines | Header is a four-field table. Not customer-safe content goes nowhere. |
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-intro/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-intro/SKILL.md
new file mode 100644
index 00000000000..54ae8b2444c
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-intro/SKILL.md
@@ -0,0 +1,141 @@
+---
+name: twenty-partner-intro
+description: Send the partner introductions for a lead - record them in the CRM and open the ready-to-send emails in Chrome. Use once the user has reviewed a shortlist and named the partners they want to introduce, or whenever they say to make the intro, send the intros, connect the client with a partner, or generate the intro emails. Writes Application records in INVITED state, stamps introSentAt on the Opportunity, and opens each partner email as a prefilled Gmail draft. Chains after twenty-partner-shortlist.
+trigger: /twenty-partner-intro
+---
+
+# twenty-partner-intro
+
+Third and last step of the lead path.
+
+```
+twenty-lead-brief → twenty-partner-shortlist → twenty-partner-intro
+```
+
+Takes the partners the user picked and does two things: records the push in the CRM, and puts
+ready-to-send emails on screen.
+
+**This skill writes to production.** It creates Application records and stamps the
+Opportunity. Read Phase 2 before running it on a lead you are unsure about.
+
+Credentials, the `gql()` helper and every query live in `../_shared/partner-api.md`.
+
+---
+
+## Phase 0 — Inputs
+
+Three things are needed. Ask for whatever is missing rather than guessing.
+
+1. **The partners**, by name, as the user stated them. Never re-derive the list, and never
+ add a partner they did not name. If they name someone who was not on the shortlist, take
+ them: overriding the shortlist is the point of the review step.
+2. **The lead folder**, for `partner-shortlist.md` and the brief. `twenty-partner-shortlist`
+ names it at the end of its run.
+3. **The Opportunity**, created by `twenty-lead-brief` at Step 6. Search by company name. If
+ there is none, say so and ask whether to create one here or go back and run
+ `/twenty-lead-brief`.
+
+Read the Opportunity's `designDocUrl`. **Empty means stopping and asking for the Doc URL**:
+the whole point of the link is that the partner emails carry it, and an intro without the
+brief makes the partner ask for it in a round trip.
+
+Resolve each partner's contact email from `persons` → `emails.primaryEmail`. No email on
+record means saying so and leaving the `to` field blank rather than inventing an address.
+
+---
+
+## Phase 1 — Write to the CRM
+
+Do this **before** the emails. If a write fails, the user finds out before anything leaves
+their outbox.
+
+For each confirmed partner:
+
+1. **Check** `applications` filtered by `opportunityId` for an existing record for this
+ partner. One already there means leaving it alone and reporting it: re-running must not
+ create duplicates.
+2. **Create** the Application: `{ opportunityId, partnerId, state: "INVITED" }`.
+
+`INVITED` means Twenty pushed the partner at this lead. `APPLIED` means the partner came
+forward on their own through the marketplace. Never write `APPLIED` here.
+
+Then, once per run:
+
+3. **Stamp** `introSentAt` on the Opportunity with the current timestamp. Already set means
+ asking whether this is a second wave before overwriting it.
+
+4. **Verify** by reading the Applications back, then print a line per partner: created, or
+ already present.
+
+---
+
+## Phase 2 — The emails
+
+For N confirmed partners, the total is `1 + 2N`.
+
+### Rules, always applied
+
+- **English by default.** Match another language only when the lead clearly operates in one,
+ for instance a French lead. Tutoiement applies only in French.
+- **Short.** 4 to 6 sentences, never more than a short screen. Cut throat-clearing, cut a
+ recap the reader already has, cut anything the brief covers. A sentence doing no work goes.
+- **Intros are launched in parallel, so frame them as already happening.** Never "may I
+ introduce you" or "si c'est ok pour toi je te présente" or any other request for
+ permission. State that the intros are going out.
+- **No em dashes.** Use a colon or a comma.
+- Sign: `Cheers,\nRashad\nPartnerships @twenty`
+- Subject prefix: `[Twenty]`
+- No self-introduction in a partner email: they know who Rashad is.
+- **Link the brief, never attach it.** Put the `designDocUrl` in the body. A Gmail compose
+ URL cannot carry a file, and the Doc reads better than a `.md` anyway.
+
+### Email 1 — Client notification, one per run
+
+A **reply inside the existing client thread**, not a new draft. Do not open a compose window
+and do not invent a subject: a `view=cm` URL always starts a new thread. Output the body text
+only, for the user to paste as a reply.
+
+Content: the intros are going out, in parallel, to `<agency name(s)>`, who will reach out
+directly. No permission-asking, no recap, no re-introduction.
+
+### Email 2 per partner — Solo outreach
+
+- **To**: the partner contact email
+- **Subject**: `[Twenty] Partner opportunity: <Client>, <one-line project description>`
+- **Content**: why this opportunity fits their profile, the project's complexity (custom
+ objects, deployment, migration, seats), the brief link, an invitation to reply or take a
+ call.
+
+### Email 3 per partner — Three-way intro
+
+- **To**: the partner contact email
+- **CC**: the client email
+- **Subject**: `[Twenty] <Client> x <Partner>: CRM project`
+- **Content**: one sentence introducing each side, the project in two sentences, the brief
+ link, then hand off.
+
+### Opening them
+
+Open **the partner emails only** (2 and 3), sequentially, 1.5 s apart. The helper is in the
+shared reference. Email 1 is a thread reply, so it stays as text on screen.
+
+---
+
+## Phase 3 — Save and report
+
+Save each email body to the lead folder:
+
+- `email-1-client.txt`
+- `email-2-<partner-slug>-solo.txt`
+- `email-3-<partner-slug>-intro.txt`
+
+Use the partner's `slug` field, not their display name. Older lead folders use ad-hoc names
+(`email-4-intro-tatara.txt`, `email-fasttrack-codevelop.txt`); do not copy them.
+
+Close with one table:
+
+| Partner | Application | Emails opened |
+|---|---|---|
+
+Then the counts, and the reminder that Email 1 is the text to paste into the existing client
+thread.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-match/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-match/SKILL.md
deleted file mode 100644
index 6ccbc5547c1..00000000000
--- a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-match/SKILL.md
+++ /dev/null
@@ -1,202 +0,0 @@
----
-name: twenty-partner-match
-description: Match a qualified lead to Twenty partners and generate all intro emails in one run. Use when a lead folder exists and you need to find the right implementation partner, either after running twenty-partner-design-doc or standalone when partner-match-criteria.md is already present. Chains back into twenty-lead-intro-call-summary and twenty-partner-design-doc if the criteria file is missing.
-trigger: /twenty-partner-match
----
-
-# twenty-partner-match
-
-Match a qualified lead to Twenty partners and generate all intro emails in one run.
-
-Chains after `twenty-lead-intro-call-summary` → `twenty-partner-design-doc`. Can be run standalone if `partner-match-criteria.md` already exists in the lead folder.
-
----
-
-## Credentials
-
-Before running, `~/.twenty/credentials.env` must exist with:
-
-```env
-TWENTY_PARTNERS_API_URL=https://partners.twenty.com
-TWENTY_PARTNERS_API_KEY=<your key>
-
-# Only needed if the input is a Fireflies link/ID
-FIREFLIES_API_KEY=<your key>
-```
-
-The partners API key lives in `packages/twenty-apps/internal/twenty-partners/.env.prod` (gitignored) — copy it to `~/.twenty/credentials.env` on first setup. The skill reads `credentials.env` at startup and stops cleanly if a required key is missing.
-
----
-
-## Phase 0 — Prerequisites
-
-### 0a. Credentials check
-
-Read `~/.twenty/credentials.env`. Verify `TWENTY_PARTNERS_API_URL` and `TWENTY_PARTNERS_API_KEY` are present. If not, stop and tell the user exactly which key is missing and where to add it.
-
-### 0b. Brief check
-
-Look for `partner-match-criteria.md` in the lead folder.
-
-**If missing:** Ask the user what is available — a text transcript, a Fireflies meeting ID/URL, or an existing call summary or brief. Then chain:
-- Fireflies input → fetch transcript via Fireflies API (requires `FIREFLIES_API_KEY`) → `/twenty-lead-intro-call-summary` → `/twenty-partner-design-doc`
-- Text transcript → `/twenty-lead-intro-call-summary` → `/twenty-partner-design-doc`
-- Existing summary → `/twenty-partner-design-doc`
-
-`partner-match-criteria.md` is produced by `/twenty-partner-design-doc` as Step 8.
-
-**If present — be critical before proceeding.** Read the file and assess quality:
-
-- Are there at least 2 hard requirements with justification?
-- Is the language requirement explicit?
-- Are the required skills specific enough to differentiate partners (e.g. "self-hosted Docker" beats "technical")?
-- Are there red flags listed?
-
-If the brief is thin on any of these axes, say so and ask targeted follow-up questions before querying the API. A match built on a vague brief is noise. Only proceed once the criteria are solid enough to produce a meaningful ranking.
-
----
-
-## Phase 1 — Matching
-
-### 1a. Fetch candidates
-
-Query the partners API:
-
-```graphql
-query ListPartners($after: String) {
- partners(
- filter: {
- validationStage: { eq: VALIDATED }
- availability: { eq: AVAILABLE }
- }
- after: $after
- ) {
- pageInfo {
- hasNextPage
- endCursor
- }
- edges {
- node {
- id name slug languagesSpoken skills deploymentExpertise
- partnerScope partnerTier country region city introduction
- persons { edges { node { name { firstName lastName } emails { primaryEmail } } } }
- company { id name }
- }
- }
- }
-}
-```
-
-Paginate until `pageInfo.hasNextPage` is false, passing `pageInfo.endCursor` as `$after` each iteration. Endpoint: `$TWENTY_PARTNERS_API_URL/graphql`.
-
-### 1b. Evaluate and rank
-
-Evaluate every candidate against the criteria in `partner-match-criteria.md`. Apply hard requirements as eliminators first (a partner missing a hard requirement does not appear in results, even with a note). Then rank remaining candidates by fit across:
-
-- **Language** (primary) — exact match on `languagesSpoken`
-- **Skills and expertise** (primary) — semantic match: "ERP experience" is relevant to complex billing, "self-hosted Docker" maps to `SELF_HOST` deploymentExpertise, etc.
-- **Country / region** (secondary) — proximity helps but is not a blocker unless the criteria say otherwise
-
-### 1c. Present results
-
-Show **at minimum 2 candidates**, more if others score well. For each:
-
-```
-## [Partner name] — [fort / moyen / faible]
-
-**Pourquoi ça matche**
-- point 1
-- point 2
-- point 3
-
-**Ce qui manque ou est risqué**
-- point
-
-**Contacts** : [name, email if available]
-```
-
-Be honest. If only one candidate is a strong match, say so and explain why the others are weaker — don't artificially inflate scores to fill a quota.
-
-### 1d. Pause for validation
-
-Ask the user which partners to introduce. They can pick one, several, or none (and ask to search differently). Wait for explicit confirmation before generating emails.
-
----
-
-## Phase 2 — Emails
-
-For each confirmed partner, generate three email types. For N confirmed partners, the total is `1 + 2N` emails.
-
-### Email rules (always applied)
-
-- **English by default.** Write all emails in English unless the lead clearly operates in another language (e.g. a French lead) — then match it. Tutoiement only applies when writing in French.
-- **Keep it short.** Aim for 4-6 sentences, never more than a short screen. Cut throat-clearing, recaps the recipient already knows, and anything the attached brief covers. If a sentence isn't doing work, drop it.
-- Intros are launched in parallel — frame them as already happening, not as a request for permission. Never write "may I introduce you" / "si c'est ok pour toi je te présente" or any permission-asking phrasing. State that the intro(s) are going out.
-- No em dashes (`—`) — use `:` or `,` instead
-- Sign: `Cheers,\nRashad\nPartnerships @twenty`
-- Subject prefix: `[Twenty]`
-- No self-introduction for partner emails (they know who Rashad is)
-- Open in Gmail via `https://mail.google.com/mail/?view=cm&fs=1&to=...&su=...&body=...` using `open -a "Google Chrome"`
-
-### Email 1 — Client notification (one per run)
-
-This is a **reply to the existing client thread**, not a new draft. Don't open a Gmail compose for it and don't invent a subject — output the body text only so the user pastes it as a reply in the ongoing thread. No re-introduction (it's an existing conversation).
-
-- **Content**: announce that the intro(s) are going out, in parallel, to [agency name(s)] who'll reach out directly. No permission-asking, no recap.
-
-### Email 2 per partner — Solo partner outreach
-
-- **To**: partner contact email (from `persons` → `emails.primaryEmail`; leave blank if none found)
-- **Subject**: `[Twenty] Partner opportunity: [Client], [one-line project description]`
-- **Content**: why this opportunity matches their profile, project complexity (custom objects, deployment, migration, seats), invite them to respond or get on a call, brief to attach
-
-### Email 3 per partner — Three-way intro
-
-- **To**: partner contact email
-- **CC**: client email
-- **Subject**: `[Twenty] [Client] x [Partner]: CRM project`
-- **Content**: introduce client to partner (one sentence each), project in two sentences, brief to attach, hand off
-
-### Opening in Gmail
-
-Open the **partner emails only** (Email 2 and Email 3) as new Gmail drafts, sequentially with a 1.5s delay between each. Email 1 is a reply to the existing client thread — output its text for the user to paste, don't open a compose window. Use Python:
-
-```python
-import subprocess, urllib.parse, time, sys
-params = {"view": "cm", "fs": "1", "to": to, "su": subject, "body": body}
-if cc: params["cc"] = cc
-url = "https://mail.google.com/mail/?" + urllib.parse.urlencode(params)
-if sys.platform == "darwin":
- subprocess.run(["open", "-a", "Google Chrome", url])
-else:
- # Linux / Windows: fall back to the system default browser
- import webbrowser
- webbrowser.open(url)
-time.sleep(1.5)
-```
-
-Remind the user to attach `YYYY-MM-DD-<lead>-partner-brief.md` to all partner emails before sending.
-
----
-
-## Output files
-
-Save email content as text files in the lead folder for reference:
-
-- `email-1-client.txt`
-- `email-2-<partner-slug>-solo.txt`
-- `email-3-<partner-slug>-intro.txt`
-
-Use the partner's `slug` field for filenames.
-
----
-
-## Chain context
-
-This skill is the third step in the Twenty partner pipeline:
-
-```
-/twenty-lead-intro-call-summary → /twenty-partner-design-doc → /twenty-partner-match
-```
-
-The `partner-match-criteria.md` produced by `/twenty-partner-design-doc` (Step 8) is this skill's primary input. Keep the criteria file updated as you learn more about the lead — it feeds both this skill and the eventual in-product matching logic.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-meeting-recap/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-meeting-recap/SKILL.md
deleted file mode 100644
index b20aa5403f0..00000000000
--- a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-meeting-recap/SKILL.md
+++ /dev/null
@@ -1,205 +0,0 @@
----
-name: twenty-partner-meeting-recap
-description: Pull recent Fireflies partner meetings, match each to an existing Partner record by attendee email/domain, write a recap (transcript-first, Fireflies summary as fallback), and inject it as a Note on the partner's profile. Use after a batch of partner calls when you want each partner's CRM record updated with what was said. Read-only for leads/discovery calls (they have no Partner match and are skipped).
-trigger: /twenty-partner-meeting-recap
----
-
-# twenty-partner-meeting-recap
-
-After partner calls: pull the Fireflies meetings, figure out which partner each one is (by matching an attendee to an existing Partner record), summarize the call, and drop that summary as a Note on the partner's profile. Runs end to end with no per-note confirmation.
-
-Sibling of `twenty-partner-match`. This one is about **existing partners** (recap their calls), not about matching a lead to partners.
-
-Optional `--prune`: after recaps are safely in the CRM, delete the corresponding Fireflies recordings to free storage (confirmed first — see Phase 6).
-
----
-
-## Credentials
-
-Reads `~/.twenty/credentials.env`:
-
-```env
-TWENTY_PARTNERS_API_URL=https://partners.twenty.com
-TWENTY_PARTNERS_API_KEY=<your key>
-FIREFLIES_API_KEY=<your key>
-```
-
-All three are required. The partners key lives in `packages/twenty-apps/internal/twenty-partners/.env.prod` (gitignored); the Fireflies key is your personal API key. Stop cleanly and name the missing key if any is absent.
-
----
-
-## Phase 0 — Prerequisites
-
-Read `~/.twenty/credentials.env`. Verify `TWENTY_PARTNERS_API_URL`, `TWENTY_PARTNERS_API_KEY`, `FIREFLIES_API_KEY` are all present. If one is missing, stop and tell the user exactly which key to add and where.
-
----
-
-## Phase 1 — Pull meetings
-
-Default scope: **meetings from the last 2 days** (covers "yesterday"). The user can override per run — "last week", a date, or by pasting specific Fireflies URLs/IDs (the ID is the trailing `01K...` segment of `app.fireflies.ai/view/<slug>::<ID>`).
-
-List recent transcripts, then keep only those inside the scope window (Fireflies `date` is epoch milliseconds). For each kept transcript, fetch its detail (attendees + summary + sentences). See **Reference queries** for the exact GraphQL. Add a `User-Agent` header to every Fireflies request — the API rejects the default urllib agent.
-
-`transcripts(limit:)` is **capped at 50** by Fireflies — a higher value is a hard `invalid_arguments` 400, not a soft clamp. Use 50 and page if you ever need more.
-
-If two transcripts share the same partner and day (Fireflies sometimes double-records), keep the one with more sentences.
-
----
-
-## Phase 2 — Match each meeting to a Partner
-
-Only meetings tied to an existing Partner get processed. Leads/discovery calls (no Partner match) are skipped and listed at the end.
-
-1. Page through all partners once, pulling each partner's linked person emails and company domain (see Reference queries). Build two maps:
- - `email -> partner` from every `persons.edges.node.emails.primaryEmail`
- - `domain -> [partners]` from each partner's `company.domainName.primaryLinkUrl`
-2. For each meeting, take the attendee emails, drop anything `@twenty.com` and the host/organizer (that's the Twenty side). For each remaining attendee email:
- - **Exact email match** against `email -> partner` wins (strongest signal).
- - Else **domain match** against `domain -> [partners]`, skipping free providers (`gmail.com`, `outlook.com`, `hotmail.com`, `yahoo.com`, `icloud.com`, `proton.me`, etc.). If exactly one partner shares the domain, match it. If several do, **flag in the report and skip** rather than guess.
-3. The meeting title is a secondary hint only (`Partner intro between … and <name>` was the historical convention) — never the primary matcher.
-
-A meeting with no Partner match is a lead/other call: skip it, record it under "skipped" with the reason.
-
----
-
-## Phase 3 — Summarize (transcript first)
-
-For each matched meeting, pick the better source. **Judge content quality first — never write a note from nothing or from noise:**
-
-- A transcript is **usable** only if it has real content: roughly `>= 15` sentences **and** an average of `>= 4` words per sentence. A handful of one-word lines (`Platform.` `Opportunity.` `Background.`) is garbled ASR, not a transcript — treat it as unusable even though the array is non-empty.
-- **Usable transcript** → write the recap yourself from the transcript. This is the default whenever a usable transcript exists.
-- **No usable transcript, but a Fireflies summary exists** → fall back to `summary.overview` (try richer fields, then `short_summary`). Note the fallback in the source line.
-- **Neither** (no usable transcript AND empty summary) → the call is **still processing or unrecorded**. Skip it, record it under "skipped: content not ready", and move on. Today's calls often land here for a while after they end. Never inject an empty or placeholder note.
-
-Write the note in English, structured (the format validated previously). No em dashes — use `:` or `,`.
-
-```
-**TL;DR:** one-line verdict / state of the relationship.
-
-**Profil:** team size, location, languages, structure.
-**Compétences Twenty:** deployment (cloud / self-host), data model, migrations, what they've actually shipped.
-**Contexte:** background, how they found Twenty, motivation, target clients, current partnerships.
-**Next steps:** concrete follow-ups (who owes what).
-**Flags:** risks, unknowns, ASR artifacts to double-check.
-
-Source: Fireflies <transcript-id> (call <YYYY-MM-DD>, transcript|summary).
-```
-
-The `Source: Fireflies <transcript-id>` line is load-bearing: it is the dedup key for re-runs. Always include the real transcript id.
-
----
-
-## Phase 4 — Inject the Note (automatic)
-
-For each matched meeting, before writing, check whether this meeting was already noted:
-
-- Read the partner's existing notes (noteTargets filtered by `targetPartnerId`). Look for a note whose body contains `Fireflies <transcript-id>`.
-- **No such note** → create one: `createNote` with `bodyV2.markdown`, then `createNoteTarget` linking `noteId` to `targetPartnerId`. Title: `Partner call recap: <Partner name> (<YYYY-MM-DD>)`.
-- **Note already exists** → regenerate the recap, diff it against the existing body, and **append only net-new information** under a dated `**Update <YYYY-MM-DD>:**` block via `updateNote` (`bodyV2.markdown` = existing body + the new block). If nothing is new, leave it untouched.
-
-No confirmation step — match, summarize, write. Then verify each write by reading the note back and confirming the partner link resolved.
-
----
-
-## Phase 5 — Report
-
-Print one table:
-
-| Meeting (date · title) | Attendee matched | Partner | Action |
-|---|---|---|---|
-
-`Action` is one of: `created`, `updated (appended)`, `unchanged`, `skipped: no partner match`, `skipped: ambiguous domain (N partners)`, `skipped: content not ready`. End with counts (`created / updated / unchanged / skipped`).
-
----
-
-## Phase 6 — Prune (`--prune`, opt-in, deletes Fireflies recordings)
-
-Runs only when invoked with `--prune` (Fireflies storage fills up; recordings whose content is already safe in the CRM are dead weight). **Deletion is irreversible and on an external service — always confirm before deleting.**
-
-A recording is **safe to prune** only when its recap note is confirmed written this run (`created` or `updated`) **or** already exists in the CRM with this transcript's `Fireflies <id>` in its body. Never prune a meeting that was skipped, has no note, or whose note you could not verify — losing the recording would lose the only copy.
-
-1. Build the prune set from this run's safe meetings (plus, if asked to "free more", existing recap notes whose `Fireflies <id>` you can resolve to a still-present transcript).
-2. **Present the exact list** (partner, transcript id, date) and get explicit confirmation. Default to keeping the most recent unless told otherwise.
-3. Delete each confirmed transcript with `deleteTranscript(id:)`, then **verify** by re-listing and confirming the ids are absent. Report `deleted N/M` and how many transcripts remain.
-
-Matching old notes back to transcripts: yesterday's notes embed only a date, not the id, so fall back to the meeting-title person name (`Partner intro between … and <name>` / `… - <name> x Rashad`) against the partner name in the note title. New notes written by this skill carry `Fireflies <id>` in the body, so the mapping is exact going forward.
-
----
-
-## Reference queries
-
-All partner calls go to `$TWENTY_PARTNERS_API_URL/graphql` with `Authorization: Bearer $TWENTY_PARTNERS_API_KEY`. All Fireflies calls go to `https://api.fireflies.ai/graphql` with `Authorization: Bearer $FIREFLIES_API_KEY` **and** a browser `User-Agent`. Helper:
-
-```python
-import os, json, urllib.request
-creds = {}
-for line in open(os.path.expanduser("~/.twenty/credentials.env")):
- line = line.strip()
- if line and "=" in line and not line.startswith("#"):
- k, v = line.split("=", 1); creds[k] = v.strip()
-
-def gql(url, key, query, variables=None):
- body = json.dumps({"query": query, "variables": variables or {}}).encode()
- req = urllib.request.Request(url, data=body, headers={
- "Content-Type": "application/json",
- "Authorization": "Bearer " + key,
- "User-Agent": "Mozilla/5.0"})
- return json.load(urllib.request.urlopen(req, timeout=90))
-```
-
-**Fireflies — list recent transcripts** (`date` is epoch ms; `limit` max 50):
-```graphql
-query{ transcripts(limit:50){ id title date duration participants meeting_attendees{ displayName email } } }
-```
-
-**Fireflies — delete a recording (`--prune` only):**
-```graphql
-mutation($id:String!){ deleteTranscript(id:$id){ id title } }
-```
-
-**Fireflies — one transcript's detail:**
-```graphql
-query($id:String!){ transcript(id:$id){
- title date duration participants host_email organizer_email
- meeting_attendees{ displayName email }
- summary{ overview short_summary keywords }
- sentences{ speaker_name text } } }
-```
-
-**Partners — page through all with person emails + company domain:**
-```graphql
-query($a:String){ partners(after:$a){
- pageInfo{ hasNextPage endCursor }
- edges{ node{
- id name slug validationStage
- persons{ edges{ node{ name{ firstName lastName } emails{ primaryEmail } } } }
- company{ name domainName{ primaryLinkUrl } } } } } }
-```
-Paginate until `pageInfo.hasNextPage` is false, passing `endCursor` as `$a`.
-
-**Partner — existing notes (dedup check):**
-```graphql
-query($pid:UUID!){ noteTargets(filter:{ targetPartnerId:{ eq:$pid } }){
- edges{ node{ note{ id title bodyV2{ markdown } createdAt } } } } }
-```
-
-**Write a note and link it to the partner:**
-```graphql
-mutation($d:NoteCreateInput!){ createNote(data:$d){ id title } }
-# variables: { "d": { "title": "...", "bodyV2": { "markdown": "..." } } }
-
-mutation($d:NoteTargetCreateInput!){ createNoteTarget(data:$d){ id targetPartnerId } }
-# variables: { "d": { "noteId": "<note id>", "targetPartnerId": "<partner id>" } }
-```
-
-**Append to an existing note (re-run path):**
-```graphql
-mutation($id:UUID!,$d:NoteUpdateInput!){ updateNote(id:$id,data:$d){ id } }
-# variables: { "id": "<note id>", "d": { "bodyV2": { "markdown": "<existing + new block>" } } }
-```
-
-**Verify a write:**
-```graphql
-query($id:UUID!){ note(filter:{ id:{ eq:$id } }){
- id title noteTargets{ edges{ node{ targetPartnerId targetPartner{ name } } } } } }
-```
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-recap/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-recap/SKILL.md
new file mode 100644
index 00000000000..380466ee3f2
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-recap/SKILL.md
@@ -0,0 +1,149 @@
+---
+name: twenty-partner-recap
+description: Pull recent Fireflies partner meetings, match each to an existing Partner record by attendee email or domain, write a recap (transcript-first, Fireflies summary as fallback), and inject it as a Note on the partner's profile. Use after a batch of partner calls when you want each partner's CRM record updated with what was said. Leads and discovery calls have no Partner match and are skipped. Pass --prune to delete the Fireflies recordings once the recaps are safely in the CRM.
+trigger: /twenty-partner-recap
+---
+
+# twenty-partner-recap
+
+Network upkeep, not the lead path. After a batch of partner calls: pull the Fireflies
+meetings, work out which partner each one is, summarize the call, and drop that summary as a
+Note on the partner's profile. Runs end to end with no per-note confirmation.
+
+The recap notes it writes are what `twenty-partner-shortlist` later reads to tell a real
+capability from a partner's own marketing copy. Roughly 5 of the 29 validated partners have
+one today, so every run makes the shortlist better.
+
+Optional `--prune`: after the recaps are safely in the CRM, delete the corresponding Fireflies
+recordings to free storage. Confirmed first, see Phase 6.
+
+Credentials, the `gql()` helper and every query live in `../_shared/partner-api.md`. This
+skill needs all three keys.
+
+---
+
+## Phase 1 — Pull meetings
+
+Default scope: **the last 2 days**, which covers "yesterday". The user can override per run:
+"last week", a date, or pasted Fireflies URLs and IDs.
+
+List recent transcripts, keep the ones inside the window (`date` is epoch milliseconds), then
+fetch each kept transcript's detail.
+
+If two transcripts share the same partner and day (Fireflies sometimes double-records), keep
+the one with more sentences.
+
+---
+
+## Phase 2 — Match each meeting to a Partner
+
+Only a meeting tied to an existing Partner gets processed. A lead or discovery call has no
+Partner match: skip it and list it at the end.
+
+1. Page through all partners once, building two maps:
+ - `email → partner` from every `persons.edges.node.emails.primaryEmail`
+ - `domain → [partners]` from each `company.domainName.primaryLinkUrl`
+2. For each meeting, take the attendee emails and drop anything `@twenty.com` plus the host
+ and organizer: that is the Twenty side. For each remaining attendee:
+ - **Exact email match** wins. It is the strongest signal.
+ - Otherwise **domain match**, skipping free providers (`gmail.com`, `outlook.com`,
+ `hotmail.com`, `yahoo.com`, `icloud.com`, `proton.me` and friends). Exactly one partner
+ on the domain means a match. Several means **flag it in the report and skip**, never
+ guess.
+3. The meeting title is a secondary hint only (`Partner intro between … and <name>` was the
+ historical convention). Never the primary matcher.
+
+---
+
+## Phase 3 — Summarize, transcript first
+
+Judge content quality before writing. **Never write a note from nothing or from noise.**
+
+- A transcript is **usable** only with real content: roughly 15 sentences or more **and** an
+ average of 4 words or more per sentence. A handful of one-word lines (`Platform.`
+ `Opportunity.` `Background.`) is garbled ASR, not a transcript. Treat it as unusable even
+ though the array is not empty.
+- **Usable transcript** → write the recap yourself from the transcript. The default whenever
+ one exists.
+- **No usable transcript but a Fireflies summary exists** → fall back to `summary.overview`,
+ then richer fields, then `short_summary`. Note the fallback in the source line.
+- **Neither** → the call is still processing or was never recorded. Skip it, record it as
+ "skipped: content not ready", move on. Today's calls often land here for a while. Never
+ inject an empty or placeholder note.
+
+Write the note in English, structured. No em dashes: use a colon or a comma.
+
+```
+**TL;DR:** one-line verdict / state of the relationship.
+
+**Profil:** team size, location, languages, structure.
+**Compétences Twenty:** deployment (cloud / self-host), data model, migrations, what they've
+actually shipped.
+**Contexte:** background, how they found Twenty, motivation, target clients, current
+partnerships.
+**Next steps:** concrete follow-ups (who owes what).
+**Flags:** risks, unknowns, ASR artifacts to double-check.
+
+Source: Fireflies <transcript-id> (call <YYYY-MM-DD>, transcript|summary).
+```
+
+The `Source: Fireflies <transcript-id>` line is load-bearing: it is the dedup key for re-runs
+and the prune key for Phase 6. Always include the real transcript id.
+
+**Compétences Twenty is the section that matters downstream.** It is the only place a
+verified capability gets recorded, as opposed to what the partner writes about themselves.
+State what they have actually shipped, not what they say they can do.
+
+---
+
+## Phase 4 — Inject the Note
+
+For each matched meeting, check first whether it was already noted: read the partner's notes
+(`noteTargets` filtered by `targetPartnerId`) and look for a body containing
+`Fireflies <transcript-id>`.
+
+- **No such note** → `createNote` with `bodyV2.markdown`, then `createNoteTarget` linking
+ `noteId` to `targetPartnerId`. Title: `Partner call recap: <Partner name> (<YYYY-MM-DD>)`.
+- **Note exists** → regenerate the recap, diff it against the existing body, and append
+ **only net-new information** under a dated `**Update <YYYY-MM-DD>:**` block via
+ `updateNote`. Nothing new means leaving it untouched.
+
+No confirmation step: match, summarize, write. Then verify each write by reading the note back
+and confirming the partner link resolved.
+
+---
+
+## Phase 5 — Report
+
+One table:
+
+| Meeting (date · title) | Attendee matched | Partner | Action |
+|---|---|---|---|
+
+`Action` is one of `created`, `updated (appended)`, `unchanged`, `skipped: no partner match`,
+`skipped: ambiguous domain (N partners)`, `skipped: content not ready`. End with the counts.
+
+---
+
+## Phase 6 — Prune (`--prune`, opt-in, deletes Fireflies recordings)
+
+Runs only with `--prune`. Fireflies storage fills up, and a recording whose content is
+already safe in the CRM is dead weight. **Deletion is irreversible and on an external
+service, so always confirm before deleting.**
+
+A recording is **safe to prune** only when its recap note was confirmed written this run
+(`created` or `updated`), **or** already exists in the CRM with this transcript's
+`Fireflies <id>` in its body. Never prune a meeting that was skipped, has no note, or whose
+note you could not verify: losing the recording loses the only copy.
+
+1. Build the prune set from this run's safe meetings. If asked to "free more", add existing
+ recap notes whose `Fireflies <id>` resolves to a still-present transcript.
+2. **Present the exact list** (partner, transcript id, date) and get explicit confirmation.
+ Default to keeping the most recent unless told otherwise.
+3. Delete each confirmed transcript with `deleteTranscript(id:)`, then **verify** by
+ re-listing and confirming the ids are gone. Report `deleted N/M` and how many remain.
+
+Matching old notes back to transcripts: notes written before this skill embed only a date, not
+an id, so fall back to the meeting-title person name (`Partner intro between … and <name>`,
+`… - <name> x Rashad`) against the partner name in the note title. Notes written by this skill
+carry `Fireflies <id>` in the body, so the mapping is exact going forward.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-shortlist/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-shortlist/SKILL.md
new file mode 100644
index 00000000000..7e955072803
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-shortlist/SKILL.md
@@ -0,0 +1,146 @@
+---
+name: twenty-partner-shortlist
+description: Shortlist the Twenty partners who fit a lead, with the reason for each, and stop so the user can review. Use when the user asks who to introduce, who fits this deal, which partners to consider, or to match a lead to partners. Works from a lead folder's partner-match-criteria.md, or straight from an Opportunity's need and requirements for a website form submission that has no call behind it. Read-only - it never writes to the CRM and never writes emails. Chains forward into twenty-partner-intro once the user has picked.
+trigger: /twenty-partner-shortlist
+---
+
+# twenty-partner-shortlist
+
+Second step of the lead path.
+
+```
+twenty-lead-brief → twenty-partner-shortlist → twenty-partner-intro
+```
+
+Produce a shortlist of partners who fit this lead, each with the reason, and **stop**. The
+user reviews it, adds, removes and changes it, then runs `twenty-partner-intro` with the
+names they settled on.
+
+**This skill is read-only and email-free.** It never writes to the CRM. It never drafts,
+opens or sends an email. Those belong to `twenty-partner-intro`. That separation is the whole
+point: a stop instruction sitting above email instructions in the same file gets walked past,
+so the barrier is the end of this skill.
+
+Credentials, the `gql()` helper and the partner query live in `../_shared/partner-api.md`.
+
+---
+
+## Phase 0 — Inputs
+
+Criteria come from one of two places. Check them in this order.
+
+**1. `partner-match-criteria.md` in the lead folder.** The richer source, produced by
+`/twenty-lead-brief` at Step 5. Use it whenever it exists.
+
+**2. The Opportunity's own `need` and `requirements`.** A lead that arrived through the
+website form (`submit-client-brief`) has no call, no transcript and no lead folder, but it
+does have structured content in the CRM: `need` is what they want, and `requirements` carries
+the hosting, seats, country, languages, timeline and budget block. That is enough to
+shortlist on. Read the Opportunity and treat those two fields as the criteria.
+
+Names ending in `— marketplace brief` are always this second case. Never bounce one back to
+`/twenty-lead-brief`: there is no transcript to give it, so that is a dead end.
+
+**Neither?** Ask what exists (a transcript, a Fireflies ID or URL, an existing summary) and
+run `/twenty-lead-brief` first.
+
+**With a criteria file, be critical before querying anything.** Read it and check:
+
+- At least 2 hard requirements, each with a justification.
+- The language requirement is explicit.
+- The required skills are specific enough to separate one partner from another. "Self-hosted
+ Docker" does that; "technical" does not.
+- Red flags are listed.
+
+Thin on any axis means saying so and asking targeted questions first. A shortlist built on a
+vague brief is noise.
+
+**Working from `need` and `requirements` instead**, the same scrutiny applies but the bar is
+lower: a form submission is short by design. Name what is missing (the criteria file would
+have carried red flags and an engagement model) and shortlist on what is there. Say in the
+output which of the two sources you used, so nobody mistakes a form-level match for a
+call-level one.
+
+---
+
+## Phase 1 — Fetch and filter
+
+Query every `VALIDATED` and `AVAILABLE` partner (see the shared reference). Paginate to the
+end.
+
+Apply the eliminators in this order. Each one is a hard fact, never a judgement.
+
+**1. Empty profile.** A partner with no `country`, no `deploymentExpertise` and no
+`introduction` cannot be assessed. Drop them and name them in one line at the bottom. As of
+the last check that is 6 of the 29 validated partners, so the line is short and it doubles as
+a chase list.
+
+**2. Hard requirements from the criteria file.** Language and deployment are the usual two. A
+partner missing a hard requirement does not appear among the candidates, not even with a
+caveat.
+
+**Price is never an eliminator.** Roughly half the partners have no rate on record, and at
+least one rate is a day rate entered in an hourly field, so any threshold would cut on noise.
+Price is shown as a fact and the user decides.
+
+---
+
+## Phase 2 — The shortlist
+
+2 to 4 candidates by default. More only if the user asks.
+
+For each, in this format:
+
+```
+## <Partner name> — fort / moyen / faible
+
+**Pourquoi ça matche**
+- point
+- point
+- point
+
+**Ce qui manque ou est risqué**
+- point
+
+**Tarif** : <hourly> /h (≈ <hourly × 8> /jour) · budget projet min <amount>
+**Contacts** : <name>, <email>
+```
+
+Rules:
+
+- **Be honest.** One strong candidate and two weak ones is a real answer. Say why the others
+ are weaker. Never inflate a score to fill a quota.
+- **Never invent a capability.** An `introduction` is marketing copy the partner wrote about
+ themselves. Only one partner in 29 has `twentyExperience` filled, so proof of real Twenty
+ work is rare and worth calling out when it exists.
+- Read the partner's **notes** (`noteTargets` filtered by `targetPartnerId`) when there are
+ any. A `Partner call recap:` note carries what was actually said on a call, which beats
+ self-written copy. About 5 partners have one.
+- `partnerTier` and `ranking` are the user's own past judgements. Report them where set;
+ never let them reorder the list.
+
+Head the output with the lead's budget line from the criteria file, usually "not stated".
+Show each partner's rate next to it. Do not compute a verdict from the comparison.
+
+**Then list the ones you did not shortlist**, by name, one line, with the one fact that kept
+them out:
+
+```
+Non retenus : Smotly (pas d'allemand) · OPALIA (cloud seulement) · Buildrhaus (…) · …
+Écartés, profil vide : Giacomo · Shubham · Gaurav Trivedi · Devreet Dulay · Benjamin Reynolds
+```
+
+Without this the user can only remove, never add. Adding is half of what the review is for.
+
+---
+
+## Phase 3 — Save and stop
+
+Save the whole output to `partner-shortlist.md` in the lead folder. Working from an
+Opportunity, there is no folder yet: create `partners-experience/<company>/` and save it
+there, so `twenty-partner-intro` has somewhere to write. Say which folder you used.
+
+Then **stop**. Tell the user they can add, remove or change any candidate, and that
+`/twenty-partner-intro` takes the names they settle on.
+
+Do not ask "shall I write the emails?". Do not draft one in advance. End here.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-triage/SKILL.md b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-triage/SKILL.md
new file mode 100644
index 00000000000..7f83185a777
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-triage/SKILL.md
@@ -0,0 +1,115 @@
+---
+name: twenty-partner-triage
+description: Rank the partner-application backlog by net-new value and hand back a short chase-list of applicants worth a personal nudge. Use when the user wants to triage, rank, or prioritize partner applications, find which applicants are worth chasing, run the daily or weekly application review, or asks "who should I reach out to" / "which applications matter". Reads the live partners workspace, read-only, never mutates a record.
+trigger: /twenty-partner-triage
+---
+
+# twenty-partner-triage
+
+Network upkeep, not the lead path. Rank `APPLICATION`-stage partners by the value they would
+*add* (geographies and languages the roster doesn't yet cover, plus proof of real Twenty work)
+and hand back a short **chase-list**: the applicants worth a personal nudge.
+
+**The door stays open for everyone.** This skill rejects nobody and filters nobody out of the
+pipeline. It just makes sure the good applicants bubble up so they don't rot. The point is a
+few high-confidence partners, not maximum coverage.
+
+Read-only. It never mutates a record.
+
+Credentials live in `../_shared/partner-api.md`. This skill needs the partners URL and key.
+
+---
+
+## Phase 0 — Run the ranker
+
+```bash
+python3 "$(dirname "$0")/rank.py" # or: python3 rank.py from the skill dir
+```
+
+`rank.py` is the deterministic core. It pulls every partner, computes each applicant's
+net-new geo, language, scope and skills against the **VALIDATED** baseline, detects a "real
+Twenty work" proof signal in the notes, scores, and prints ranked JSON. It calls no LLM: the
+judgment lives in you, at Phase 1.
+
+Each ranked entry: `name, score, tier (A/B/C), new_geo, new_lang, new_scope, new_skills,
+proof{workspace_url|customers|migration}, team, contact_name, email, linkedin, website,
+notes`.
+
+Scoring, tunable in `rank.py`: geo +3 each, language +3 each, scope +1, skills +1 capped at 3
+(so a dev shop spraying skill lists can't dominate), proof +6. Any proof signal means at least
+tier A.
+
+**Scope: every application is scored.** There is no booking signal on the Partner object, so
+the ranker cannot narrow to the applicants who never booked a call. That is the true chase
+set, and reaching it would mean adding a field and populating it from the calendar. Until
+someone does, say plainly in the output that the list covers all applications, booked or not.
+
+A missing-credentials error means stopping and naming the key to add.
+
+---
+
+## Phase 1 — Judgment pass (this is the point)
+
+The score surfaces; you decide. Read the `notes` of the **top ~15**, plus anything tier-B or
+tier-C with a non-trivial note, and adjust:
+
+- **Rescue the motivated-but-unobvious.** Thin checkboxes but notes showing real intent, a
+ live Twenty instance, named customers, or a thoughtful pitch is a chase even at a low
+ score. This is the whole reason a human reads the notes: the applicants who do things the
+ form doesn't capture are exactly the ones not to lose.
+- **Sanity-check volume inflation.** A high score driven by 6 net-new *languages* from one
+ solo, or a long skills list, may be aspirational. Confirm against the notes before ranking
+ it top. Real net-new geography with proof beats a long list every time.
+- **Demote noise.** Empty notes, agency spam, or `Tally submission: <id>` with nothing else is
+ tier C regardless of score. Don't chase them.
+- **Note proof quality.** `workspace_url` and `customers` together, a live workspace with
+ named clients, is the strongest signal, stronger than the raw score. Call it out.
+
+Don't invent facts. An ambiguous note gets said so, not upgraded on a guess.
+
+---
+
+## Phase 2 — Output the chase-list
+
+A tight digest, grouped by tier, A first. Lead with the count and the scope caveat.
+
+```
+# Partner application triage — N applications ranked (all applications, no booking signal on the model)
+
+## Chase now (Tier A — fills a gap AND/OR proven)
+- **<name>** (<team>) — +<geo>/<lang>; proof: <workspace+customers/…>
+ why: <one line, drawn from notes>
+ reach: <email> · <linkedin>
+
+## Worth a look (Tier B)
+- <name> — <one line>; reach: <email>
+
+## Skip for now (Tier C) — <count>, not listed (empty/spam/no gap)
+```
+
+Rules:
+
+- Tier A is the actual worklist. Keep it short. Eighteen entries means the proof-backed
+ gap-fillers go first and the volume-only ones go last.
+- Always give a reach handle: email from `contact_name` or `email`, else linkedin, else
+ website. None on record means saying "no contact on record", which is itself a data-quality
+ flag.
+- Be honest. A handful genuinely worth chasing is a real answer. Don't pad the A-tier.
+
+---
+
+## What this is not
+
+- **Not a gate.** It never moves anyone to `REJECTED` or out of the funnel.
+- **Not a writer.** It never edits a record. Surfacing only.
+- **Not the production cron.** This is the dev surface for the ranking. Once the chase-list is
+ trustworthy, `rank.py` is what gets ported to a daily logic-function cron that writes
+ `ranking` and a tier onto each record so the workspace view sorts itself. The judgment pass
+ stays here, for the runs where a human is in the loop. Build the skill, trust it, port the
+ cheap part. Don't build both.
+
+## Self-check
+
+`python3 rank.py --selftest` asserts that the scoring orders a gap-filler-with-proof above a
+skill-sprayer above an empty record, and that skill volume stays capped. Run it after any edit
+to the weights or the signal regexes.
diff --git a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-application-triage/rank.py b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-triage/rank.py
similarity index 94%
rename from packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-application-triage/rank.py
rename to packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-triage/rank.py
index 10b8c33f839..ad7469267ad 100644
--- a/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-application-triage/rank.py
+++ b/packages/twenty-apps/internal/twenty-partners/src/skills/twenty-partner-triage/rank.py
@@ -1,5 +1,5 @@
#!/usr/bin/env python3
-"""Deterministic ranker for the twenty-partner-application-triage skill.
+"""Deterministic ranker for the twenty-partner-triage skill.
Ranks APPLICATION-stage partners by NET-NEW value vs the current VALIDATED set:
geography and language we don't yet cover (weighted high), plus a "real Twenty
@@ -50,7 +50,7 @@ def load_creds():
def fetch_all_partners(url, key):
recs, after = [], None
while True:
- path = f"{url}/rest/partners?limit=60&depth=1" + (f"&starting_after={after}" if after else "")
+ path = f"{url}/rest/partners?limit=200&depth=1" + (f"&starting_after={after}" if after else "")
req = urllib.request.Request(path, headers={"Authorization": f"Bearer {key}", "User-Agent": "Mozilla/5.0"})
data = json.load(urllib.request.urlopen(req))
page = data["data"]["partners"]
@@ -156,16 +156,11 @@ def score_one(rec, base):
def rank(recs):
validated = [r for r in recs if r.get("validationStage") == "VALIDATED"]
apps = [r for r in recs if r.get("validationStage") == "APPLICATION"]
- # Forward-compat: once callBookedAt exists, narrow to the un-booked (the chase set).
- has_booked_field = any("callBookedAt" in r for r in recs)
- if has_booked_field:
- apps = [r for r in apps if not r.get("callBookedAt")]
base = baseline(validated)
ranked = sorted((score_one(r, base) for r in apps), key=lambda d: -d["score"])
return {
"validated_count": len(validated),
"application_count": len(apps),
- "booking_state_wired": has_booked_field,
"coverage": {k: sorted(v) for k, v in base.items()},
"ranked": ranked,
}
diff --git a/packages/twenty-apps/internal/twenty-partners/yarn.lock b/packages/twenty-apps/internal/twenty-partners/yarn.lock
index 4634adea5a2..590c4048bf6 100644
--- a/packages/twenty-apps/internal/twenty-partners/yarn.lock
+++ b/packages/twenty-apps/internal/twenty-partners/yarn.lock
@@ -34,12 +34,12 @@ __metadata:
languageName: node
linkType: hard
-"@emnapi/runtime@npm:^1.7.0":
- version: 1.11.2
- resolution: "@emnapi/runtime@npm:1.11.2"
+"@emnapi/runtime@npm:^1.11.1":
+ version: 1.11.3
+ resolution: "@emnapi/runtime@npm:1.11.3"
dependencies:
tslib: "npm:^2.4.0"
- checksum: 10c0/d8d500059fe9c0864571c79ce29439c1b6fb44d7ec4ac865a2aaaa7469194e5d91ebdc820cabd37c3d373478b725a8b60771733e4743cfef41fc86d9a1f2eab0
+ checksum: 10c0/a00f1020fefb9d4145c367f93a9fddb383a00da8ffd7871e20b19659890379b83aeecb9f84d7d0eda5456343f4a09eb05b0acb5153b0d3d889539dedb1ed87c3
languageName: node
linkType: hard
@@ -254,18 +254,18 @@ __metadata:
languageName: node
linkType: hard
-"@img/colour@npm:^1.0.0":
+"@img/colour@npm:^1.1.0":
version: 1.1.0
resolution: "@img/colour@npm:1.1.0"
checksum: 10c0/2ebea2c0bbaee73b99badcefa04e1e71d83f36e5369337d3121dca841f4569533c4e2faddda6d62dd247f0d5cca143711f9446c59bcce81e427ba433a7a94a17
languageName: node
linkType: hard
-"@img/sharp-darwin-arm64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-darwin-arm64@npm:0.34.5"
+"@img/sharp-darwin-arm64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-darwin-arm64@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-darwin-arm64": "npm:1.2.4"
+ "@img/sharp-libvips-darwin-arm64": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-darwin-arm64":
optional: true
@@ -273,11 +273,11 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-darwin-x64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-darwin-x64@npm:0.34.5"
+"@img/sharp-darwin-x64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-darwin-x64@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-darwin-x64": "npm:1.2.4"
+ "@img/sharp-libvips-darwin-x64": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-darwin-x64":
optional: true
@@ -285,81 +285,90 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-libvips-darwin-arm64@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-darwin-arm64@npm:1.2.4"
+"@img/sharp-freebsd-wasm32@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-freebsd-wasm32@npm:0.35.3"
+ dependencies:
+ "@img/sharp-wasm32": "npm:0.35.3"
+ conditions: os=freebsd
+ languageName: node
+ linkType: hard
+
+"@img/sharp-libvips-darwin-arm64@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-darwin-arm64@npm:1.3.2"
conditions: os=darwin & cpu=arm64
languageName: node
linkType: hard
-"@img/sharp-libvips-darwin-x64@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-darwin-x64@npm:1.2.4"
+"@img/sharp-libvips-darwin-x64@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-darwin-x64@npm:1.3.2"
conditions: os=darwin & cpu=x64
languageName: node
linkType: hard
-"@img/sharp-libvips-linux-arm64@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-linux-arm64@npm:1.2.4"
+"@img/sharp-libvips-linux-arm64@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-linux-arm64@npm:1.3.2"
conditions: os=linux & cpu=arm64 & libc=glibc
languageName: node
linkType: hard
-"@img/sharp-libvips-linux-arm@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-linux-arm@npm:1.2.4"
+"@img/sharp-libvips-linux-arm@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-linux-arm@npm:1.3.2"
conditions: os=linux & cpu=arm & libc=glibc
languageName: node
linkType: hard
-"@img/sharp-libvips-linux-ppc64@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-linux-ppc64@npm:1.2.4"
+"@img/sharp-libvips-linux-ppc64@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-linux-ppc64@npm:1.3.2"
conditions: os=linux & cpu=ppc64 & libc=glibc
languageName: node
linkType: hard
-"@img/sharp-libvips-linux-riscv64@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-linux-riscv64@npm:1.2.4"
+"@img/sharp-libvips-linux-riscv64@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-linux-riscv64@npm:1.3.2"
conditions: os=linux & cpu=riscv64 & libc=glibc
languageName: node
linkType: hard
-"@img/sharp-libvips-linux-s390x@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-linux-s390x@npm:1.2.4"
+"@img/sharp-libvips-linux-s390x@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-linux-s390x@npm:1.3.2"
conditions: os=linux & cpu=s390x & libc=glibc
languageName: node
linkType: hard
-"@img/sharp-libvips-linux-x64@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-linux-x64@npm:1.2.4"
+"@img/sharp-libvips-linux-x64@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-linux-x64@npm:1.3.2"
conditions: os=linux & cpu=x64 & libc=glibc
languageName: node
linkType: hard
-"@img/sharp-libvips-linuxmusl-arm64@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-linuxmusl-arm64@npm:1.2.4"
+"@img/sharp-libvips-linuxmusl-arm64@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-linuxmusl-arm64@npm:1.3.2"
conditions: os=linux & cpu=arm64 & libc=musl
languageName: node
linkType: hard
-"@img/sharp-libvips-linuxmusl-x64@npm:1.2.4":
- version: 1.2.4
- resolution: "@img/sharp-libvips-linuxmusl-x64@npm:1.2.4"
+"@img/sharp-libvips-linuxmusl-x64@npm:1.3.2":
+ version: 1.3.2
+ resolution: "@img/sharp-libvips-linuxmusl-x64@npm:1.3.2"
conditions: os=linux & cpu=x64 & libc=musl
languageName: node
linkType: hard
-"@img/sharp-linux-arm64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-linux-arm64@npm:0.34.5"
+"@img/sharp-linux-arm64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-linux-arm64@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-linux-arm64": "npm:1.2.4"
+ "@img/sharp-libvips-linux-arm64": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-linux-arm64":
optional: true
@@ -367,11 +376,11 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-linux-arm@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-linux-arm@npm:0.34.5"
+"@img/sharp-linux-arm@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-linux-arm@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-linux-arm": "npm:1.2.4"
+ "@img/sharp-libvips-linux-arm": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-linux-arm":
optional: true
@@ -379,11 +388,11 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-linux-ppc64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-linux-ppc64@npm:0.34.5"
+"@img/sharp-linux-ppc64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-linux-ppc64@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-linux-ppc64": "npm:1.2.4"
+ "@img/sharp-libvips-linux-ppc64": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-linux-ppc64":
optional: true
@@ -391,11 +400,11 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-linux-riscv64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-linux-riscv64@npm:0.34.5"
+"@img/sharp-linux-riscv64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-linux-riscv64@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-linux-riscv64": "npm:1.2.4"
+ "@img/sharp-libvips-linux-riscv64": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-linux-riscv64":
optional: true
@@ -403,11 +412,11 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-linux-s390x@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-linux-s390x@npm:0.34.5"
+"@img/sharp-linux-s390x@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-linux-s390x@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-linux-s390x": "npm:1.2.4"
+ "@img/sharp-libvips-linux-s390x": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-linux-s390x":
optional: true
@@ -415,11 +424,11 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-linux-x64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-linux-x64@npm:0.34.5"
+"@img/sharp-linux-x64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-linux-x64@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-linux-x64": "npm:1.2.4"
+ "@img/sharp-libvips-linux-x64": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-linux-x64":
optional: true
@@ -427,11 +436,11 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-linuxmusl-arm64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-linuxmusl-arm64@npm:0.34.5"
+"@img/sharp-linuxmusl-arm64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-linuxmusl-arm64@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-linuxmusl-arm64": "npm:1.2.4"
+ "@img/sharp-libvips-linuxmusl-arm64": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-linuxmusl-arm64":
optional: true
@@ -439,11 +448,11 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-linuxmusl-x64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-linuxmusl-x64@npm:0.34.5"
+"@img/sharp-linuxmusl-x64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-linuxmusl-x64@npm:0.35.3"
dependencies:
- "@img/sharp-libvips-linuxmusl-x64": "npm:1.2.4"
+ "@img/sharp-libvips-linuxmusl-x64": "npm:1.3.2"
dependenciesMeta:
"@img/sharp-libvips-linuxmusl-x64":
optional: true
@@ -451,32 +460,41 @@ __metadata:
languageName: node
linkType: hard
-"@img/sharp-wasm32@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-wasm32@npm:0.34.5"
+"@img/sharp-wasm32@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-wasm32@npm:0.35.3"
dependencies:
- "@emnapi/runtime": "npm:^1.7.0"
+ "@emnapi/runtime": "npm:^1.11.1"
+ checksum: 10c0/627125c330ab96e324c888d3c43fa72eb7c975e653277755121df14447373b7b47b011a1eae9c8c360a9535a7072bd6205b6498974006124b513c033a07e0e32
+ languageName: node
+ linkType: hard
+
+"@img/sharp-webcontainers-wasm32@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-webcontainers-wasm32@npm:0.35.3"
+ dependencies:
+ "@img/sharp-wasm32": "npm:0.35.3"
conditions: cpu=wasm32
languageName: node
linkType: hard
-"@img/sharp-win32-arm64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-win32-arm64@npm:0.34.5"
+"@img/sharp-win32-arm64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-win32-arm64@npm:0.35.3"
conditions: os=win32 & cpu=arm64
languageName: node
linkType: hard
-"@img/sharp-win32-ia32@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-win32-ia32@npm:0.34.5"
+"@img/sharp-win32-ia32@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-win32-ia32@npm:0.35.3"
conditions: os=win32 & cpu=ia32
languageName: node
linkType: hard
-"@img/sharp-win32-x64@npm:0.34.5":
- version: 0.34.5
- resolution: "@img/sharp-win32-x64@npm:0.34.5"
+"@img/sharp-win32-x64@npm:0.35.3":
+ version: 0.35.3
+ resolution: "@img/sharp-win32-x64@npm:0.35.3"
conditions: os=win32 & cpu=x64
languageName: node
linkType: hard
@@ -3127,7 +3145,7 @@ __metadata:
languageName: node
linkType: hard
-"semver@npm:^7.7.3":
+"semver@npm:^7.8.5":
version: 7.8.5
resolution: "semver@npm:7.8.5"
bin:
@@ -3136,42 +3154,45 @@ __metadata:
languageName: node
linkType: hard
-"sharp@npm:^0.34.5":
- version: 0.34.5
- resolution: "sharp@npm:0.34.5"
- dependencies:
- "@img/colour": "npm:^1.0.0"
- "@img/sharp-darwin-arm64": "npm:0.34.5"
- "@img/sharp-darwin-x64": "npm:0.34.5"
- "@img/sharp-libvips-darwin-arm64": "npm:1.2.4"
- "@img/sharp-libvips-darwin-x64": "npm:1.2.4"
- "@img/sharp-libvips-linux-arm": "npm:1.2.4"
- "@img/sharp-libvips-linux-arm64": "npm:1.2.4"
- "@img/sharp-libvips-linux-ppc64": "npm:1.2.4"
- "@img/sharp-libvips-linux-riscv64": "npm:1.2.4"
- "@img/sharp-libvips-linux-s390x": "npm:1.2.4"
- "@img/sharp-libvips-linux-x64": "npm:1.2.4"
- "@img/sharp-libvips-linuxmusl-arm64": "npm:1.2.4"
- "@img/sharp-libvips-linuxmusl-x64": "npm:1.2.4"
- "@img/sharp-linux-arm": "npm:0.34.5"
- "@img/sharp-linux-arm64": "npm:0.34.5"
- "@img/sharp-linux-ppc64": "npm:0.34.5"
- "@img/sharp-linux-riscv64": "npm:0.34.5"
- "@img/sharp-linux-s390x": "npm:0.34.5"
- "@img/sharp-linux-x64": "npm:0.34.5"
- "@img/sharp-linuxmusl-arm64": "npm:0.34.5"
- "@img/sharp-linuxmusl-x64": "npm:0.34.5"
- "@img/sharp-wasm32": "npm:0.34.5"
- "@img/sharp-win32-arm64": "npm:0.34.5"
- "@img/sharp-win32-ia32": "npm:0.34.5"
- "@img/sharp-win32-x64": "npm:0.34.5"
+"sharp@npm:^0.35.3":
+ version: 0.35.3
+ resolution: "sharp@npm:0.35.3"
+ dependencies:
+ "@img/colour": "npm:^1.1.0"
+ "@img/sharp-darwin-arm64": "npm:0.35.3"
+ "@img/sharp-darwin-x64": "npm:0.35.3"
+ "@img/sharp-freebsd-wasm32": "npm:0.35.3"
+ "@img/sharp-libvips-darwin-arm64": "npm:1.3.2"
+ "@img/sharp-libvips-darwin-x64": "npm:1.3.2"
+ "@img/sharp-libvips-linux-arm": "npm:1.3.2"
+ "@img/sharp-libvips-linux-arm64": "npm:1.3.2"
+ "@img/sharp-libvips-linux-ppc64": "npm:1.3.2"
+ "@img/sharp-libvips-linux-riscv64": "npm:1.3.2"
+ "@img/sharp-libvips-linux-s390x": "npm:1.3.2"
+ "@img/sharp-libvips-linux-x64": "npm:1.3.2"
+ "@img/sharp-libvips-linuxmusl-arm64": "npm:1.3.2"
+ "@img/sharp-libvips-linuxmusl-x64": "npm:1.3.2"
+ "@img/sharp-linux-arm": "npm:0.35.3"
+ "@img/sharp-linux-arm64": "npm:0.35.3"
+ "@img/sharp-linux-ppc64": "npm:0.35.3"
+ "@img/sharp-linux-riscv64": "npm:0.35.3"
+ "@img/sharp-linux-s390x": "npm:0.35.3"
+ "@img/sharp-linux-x64": "npm:0.35.3"
+ "@img/sharp-linuxmusl-arm64": "npm:0.35.3"
+ "@img/sharp-linuxmusl-x64": "npm:0.35.3"
+ "@img/sharp-webcontainers-wasm32": "npm:0.35.3"
+ "@img/sharp-win32-arm64": "npm:0.35.3"
+ "@img/sharp-win32-ia32": "npm:0.35.3"
+ "@img/sharp-win32-x64": "npm:0.35.3"
detect-libc: "npm:^2.1.2"
- semver: "npm:^7.7.3"
+ semver: "npm:^7.8.5"
dependenciesMeta:
"@img/sharp-darwin-arm64":
optional: true
"@img/sharp-darwin-x64":
optional: true
+ "@img/sharp-freebsd-wasm32":
+ optional: true
"@img/sharp-libvips-darwin-arm64":
optional: true
"@img/sharp-libvips-darwin-x64":
@@ -3208,7 +3229,7 @@ __metadata:
optional: true
"@img/sharp-linuxmusl-x64":
optional: true
- "@img/sharp-wasm32":
+ "@img/sharp-webcontainers-wasm32":
optional: true
"@img/sharp-win32-arm64":
optional: true
@@ -3216,7 +3237,10 @@ __metadata:
optional: true
"@img/sharp-win32-x64":
optional: true
- checksum: 10c0/fd79e29df0597a7d5704b8461c51f944ead91a5243691697be6e8243b966402beda53ddc6f0a53b96ea3cb8221f0b244aa588114d3ebf8734fb4aefd41ab802f
+ peerDependenciesMeta:
+ "@types/node":
+ optional: true
+ checksum: 10c0/d99d60fc716aacbf42fcb0eb6d129142e0912eb23310adf48bc94e6989e27c838c5b5f507b928c723c72d265f9ceea3d4b1207e8fd5929797b23005663ce1d07
languageName: node
linkType: hard
@@ -3500,16 +3524,16 @@ __metadata:
languageName: node
linkType: hard
-"twenty-client-sdk@npm:2.23.0-alpha.2":
- version: 2.23.0-alpha.2
- resolution: "twenty-client-sdk@npm:2.23.0-alpha.2"
+"twenty-client-sdk@npm:2.31.0":
+ version: 2.31.0
+ resolution: "twenty-client-sdk@npm:2.31.0"
dependencies:
"@genql/runtime": "npm:^2.10.0"
esbuild: "npm:^0.28.1"
graphql: "npm:^16.8.1"
lodash: "npm:^4.17.21"
prettier: "npm:^3.8.3"
- checksum: 10c0/9bdee21c07c3a3369199289e16860213c9dde995e62bbdbce20ad0aa4490d8a664cd3c9a1c654bc6291189c8941616dda38df359828472330b15efdf9f4c089f
+ checksum: 10c0/03a476db2dd6092875d6929a7f96a72d79c17d95fd9e42963ba2530b3f5ceec3760a96946ec032144976c75004ee2bbbb5791bb2583dd69f7f91c6ac20cd0337
languageName: node
linkType: hard
@@ -3526,8 +3550,8 @@ __metadata:
react-dom: "npm:^19.0.0"
react-markdown: "npm:^10.1.0"
tsx: "npm:^4.0.0"
- twenty-client-sdk: "npm:2.23.0-alpha.2"
- twenty-sdk: "npm:2.23.0-alpha.2"
+ twenty-client-sdk: "npm:2.31.0"
+ twenty-sdk: "npm:2.31.0"
typescript: "npm:^5.9.3"
vite-tsconfig-paths: "npm:^4.2.1"
vitest: "npm:^4.0.0"
@@ -3535,9 +3559,9 @@ __metadata:
languageName: unknown
linkType: soft
-"twenty-sdk@npm:2.23.0-alpha.2":
- version: 2.23.0-alpha.2
- resolution: "twenty-sdk@npm:2.23.0-alpha.2"
+"twenty-sdk@npm:2.31.0":
+ version: 2.31.0
+ resolution: "twenty-sdk@npm:2.31.0"
dependencies:
"@sniptt/guards": "npm:^0.2.0"
axios: "npm:^1.16.0"
@@ -3554,14 +3578,14 @@ __metadata:
react: "npm:^19.2.0"
react-dom: "npm:^19.2.0"
semver: "npm:7.6.3"
- sharp: "npm:^0.34.5"
+ sharp: "npm:^0.35.3"
tinyglobby: "npm:^0.2.15"
- twenty-client-sdk: "npm:2.23.0-alpha.2"
+ twenty-client-sdk: "npm:2.31.0"
typescript: "npm:^5.9.3"
uuid: "npm:^13.0.2"
bin:
twenty: dist/cli.cjs
- checksum: 10c0/82f820a23bc84fb45b6ca06e237b02d71cb9c5fddc98bcdaa4838e1268a7c687242ff89f429ae7c5b30c211325de8f8d349d57f18acdb8130c1d2f677c1db913
+ checksum: 10c0/ceb42a2abb29b43243c1db41b8de6ef5a5c3140cafc1cd663026d034b9aa010aa140f656af742d5804b89ace2be9e7eea63b3c4279959aad86253f59c1b95da0
languageName: node
linkType: hard