Run Partner Fit from your own code

Both metered lanes are available over HTTP and each returns one JSON object. The division of labour: the page reads every candidate's demand evidence, places each on the depth ladder, ranks the portfolio, the ladder and where the function reports, and checks certification renewals, attribution plumbing and comp, then hands it all to the run as facts. The run writes the partnership portfolio or the attribution rules; the page then holds it to its own facts (pfreply.js).

Base URL and the response shape

Every endpoint lives under https://api.skillsafe.ai/v1/app-api, and every response has one shape:

{ "ok": true,  "data":  { ... } }
{ "ok": false, "error": { "code": "...", "message": "..." } }

The token is minted for this app (the guest call takes {"slug":"partner-fit"}), so no slug header is needed afterwards. Send it as Authorization: Bearer YOUR_TOKEN. The run body is the input object, sent bare.

The task field comes first

Two lanes, chosen by task, in the order the work runs - for the partnerships lead, then for RevOps and finance:

• portfolio - the partnership portfolio: the shape, every partner at the page's rung with its evidence and next move, governance for co-build and OEM partners, certifications with renewal owners, and where the function reports.
• attribution - the attribution rules: sourced and influenced as two capped numbers, the CRM claim at creation and its window, a rule per rung in use, comp, forecast and the executive measures.

A missing or unknown task is answered as portfolio. Both lanes send the same five fields. The facts are the page's checks, one row per line, and a line starting "must:" is a rule the reply has to hold. The page's handoff carries the portfolio into carry for the attribution lane.

The input

The rules the model applies

From the source skill, @samber/integration-partnership-strategy - the only standard the run applies:

• Partner selection is a data problem. Every shortlisted partner carries a written demand-evidence line - named deals, request counts, customer share or retention data. A candidate with none is parked, never grandfathered because someone knows someone.
• Portfolio shapes: few-and-deep (three to five partners chosen on evidence, each at co-sell depth or deeper); category-coverage breadth (one integration per adjacent category at referral or co-sell depth - cheapest, weakest per-partner economics); platform-anchor (one dominant platform partnership plus a thin long tail - effort and risk concentrated together). Dozens of shallow integrations producing no pipeline is the documented anti-pattern.
• The depth ladder runs referral, reseller, co-sell, co-build, OEM. Co-sell is the default rung - one maintained integration plus a joint pipeline motion. Step down to referral where evidence is thin. The reseller rung is deleted, not parked, when the business model cannot support partner-transacted deals. Co-build and OEM are earned: graduation needs proven joint economics and product, commercial and operational fit at once.
• Govern every co-build or OEM partner like a product: roadmap visibility from the start, a sync at least quarterly, a joint business plan with shared dated targets and which side carries the heavier lift, and QBRs that review last quarter's commitments and set the next quarter's with someone on each side who can approve resources. The legal default is a joint development agreement scoped to the integration.
• A certification is a standing cost, not a launch project: renewals recur every major platform release or every year, so each join names a renewal owner and a budgeted standing cost counted against integration-engineer headcount before signing.
• Attribution: sourced (the deal would not exist without the partner) and influenced (the deal existed and the partner materially advanced it) are two separate, capped numbers, never one blend. A partner-source field on the CRM opportunity, the claim made at deal creation with a dated ID, a short window of about 14 days, one sourced partner per deal, caps set before the quarter, equal AE comp on partner deals, partner pipeline in the same forecast review, and a rule per motion - referral, co-sell and OEM need different rules.
• The function reports into Sales by default; integrations move under Product when productization is the goal or the team already sits there; a standalone Alliances org is earned when partner-sourced revenue is a board metric and deep rungs need dedicated owners. Past roughly 100 employees, split the roles: partner managers, a partner or integration engineer and an integration product manager, with the top 10-15 partners as named accounts.
• Measure sourced against influenced revenue, activation rate (the share of signed partners ever producing a lead or revenue), time to first deal and partner CAC against direct CAC, inside the dashboards leadership already reads.

House rules

• Use only the input. Never invent a partner, a company, a figure or a date - except a value a field below asks you to propose (an owner, a cost, a cadence, a cap, a window, a target), always labelled as proposed.
• The page's rankings, rungs and checks are settled: never move a rung, rank differently or call a failed gate fine. Write the target state: where the input shows a gap, give what replaces it; the gap itself belongs in a caveat.
• No web links (http or https).
• Write in the language of the input; keep the JSON keys and the shape, rung and placement ids as given.
• Never use backticks and never write the input's field names as labels in your text. Words and terms of art from the rules above are free to use; what you never do is paste a whole sentence or quoted saying from this prompt, or state a rule with no fact of this company in it.
• Reply with ONLY one JSON object - no prose before or after, no code fences.

The replies

portfolio

Write the partnership portfolio the partnerships lead will run.

1. summary - one sentence, at most 40 words: the portfolio shape, and the first thing that must change.
2. portfolio - shape (fewdeep, breadth or anchor, exactly as the facts rank first), why (one sentence naming the moves).
3. shortlist - one object per candidate partner in the input, no others: partner (as named), evidence (its demand-evidence line, from the input; empty for a parked partner), rung (park, referral, reseller, cosell, cobuild or oem, exactly the page's rung), next (one sentence: the condition that moves it one rung deeper on the ladder itself - referral, reseller, co-sell, co-build, OEM, not the ranked order in the facts - or, for a parked partner, the evidence that would un-park it).
4. governance - one object per partner at cobuild or oem, no others ([] when none): partner, cadence (how often the two sides sync - at least quarterly, labelled proposed when the input gives none), plan (one sentence: the joint business plan's shared targets and which side carries the heavier lift now), qbr (one sentence: the role on each side with authority to approve resources - proposed when the input names none - and what it reviews).
5. certifications - one object per certification join in the input ([] when none): platform, owner (the renewal owner, as the input names one or proposed), cost (the standing cost a quarter - the input's hours, or proposed), cadence (how often it renews).
6. org - placement (sales, product or alliances, exactly as the facts rank first), why (one sentence), roles (short strings: the roles the function staffs - the split roles when the company is past about 100 employees; else []).
7. kpis - at least three short strings.
8. caveats - at most 4 short strings; [] when there is nothing to say.

{
  "task": "portfolio",
  "summary": "one sentence",
  "portfolio": { "shape": "fewdeep", "why": "one sentence" },
  "shortlist": [ { "partner": "as named", "evidence": "the evidence line", "rung": "cosell", "next": "one sentence" } ],
  "governance": [ ],
  "certifications": [ { "platform": "as named", "owner": "a role", "cost": "a cost", "cadence": "a cadence" } ],
  "org": { "placement": "sales", "why": "one sentence", "roles": [ ] },
  "kpis": [ "a measure" ],
  "caveats": [ ]
}

The page holds it to its own facts (check() in pfreply.js; any warning makes the reply flagged): the reply answers the task it was sent; no web link; no backticks; a summary of at most 40 words; the ranked portfolio shape; every candidate on the shortlist and no other, each at the page's rung with its evidence line and the condition for its next move; governance with a cadence of at least quarterly, a joint plan and the QBR for every co-build or OEM partner and no other; every planned certification with a renewal owner and a standing cost; the ranked org placement, with the split roles past about 100 employees; at least three measures.

attribution

Write the attribution rules RevOps will build into the CRM.

1. summary - one sentence, at most 40 words.
2. definitions - sourced and influenced: one sentence each, in this company's own deal terms.
3. claim - field (one sentence: the partner-source field on the CRM opportunity and the dated claim ID), timing (one sentence: claimed at deal creation, never at close), window (a number of days - the input's when it gives one of 30 or fewer, else about 14, proposed).
4. caps - sourced and influenced: one sentence each - how each is capped (a share of the quarter's bookings or a dollar ceiling), set before the quarter, labelled proposed when the input gives none.
5. motions - one object per rung the facts list as in use, no others: rung (as the facts spell it), rule (one sentence: how a deal on that motion is claimed and credited, including one sourced partner per deal where it applies).
6. comp - one sentence: how AE pay on partner deals is equalized with direct deals.
7. forecast - one sentence: how partner pipeline joins the same forecast review with the same exit criteria.
8. kpis - at least four short strings: sourced against influenced revenue, activation rate, time to first deal, partner CAC against direct CAC.
9. caveats - at most 4 short strings; [] when there is nothing to say.

{
  "task": "attribution",
  "summary": "one sentence",
  "definitions": { "sourced": "one sentence", "influenced": "one sentence" },
  "claim": { "field": "one sentence", "timing": "one sentence", "window": "14 days (proposed)" },
  "caps": { "sourced": "one sentence", "influenced": "one sentence" },
  "motions": [ { "rung": "cosell", "rule": "one sentence" } ],
  "comp": "one sentence",
  "forecast": "one sentence",
  "kpis": [ "a measure" ],
  "caveats": [ ]
}

The page requires: the reply answers the task it was sent; the same text rules; sourced and influenced defined separately; the claim on the CRM opportunity, at deal creation, inside a window of 30 days or fewer; both caps; one sourced partner per deal; a rule for each rung in use and none for unused rungs; equal AE comp; one forecast review; measures for sourced against influenced revenue, activation rate, time to first deal and partner CAC against direct CAC.

Worked examples

Three runs from the page's free samples (invented companies): the portfolio for a contract SaaS with a vibes shortlist, the attribution rules for the same company carrying that portfolio, and the portfolio for a field-service platform whose program holds. Each input is exactly what the page sends; each reply is the saved reply the sample replays, shipped unedited - but the facts and long strings are shortened in this display only, and every cut is listed under the example. The last line is the page's own check of the full reply.

portfolio - A contract SaaS with 40 integrations and a vibes shortlist

The page read it as: partners picked on relationships - evidence first; portfolio fewdeep, breadth, anchor; org sales, product, alliances; rungs Salesforce cosell, DocuSign cosell, HubSpot cosell, Brieflyne AI park, Slack park; 0 of 5 gates; failing checks: evidence, graduation, renewals, attribution, comp.

Input (facts is 2352 characters; the first 1397 are shown):

{
 "task": "portfolio",
 "company": "Company: Clausewick\nThe product and what prompted this: Contract-management SaaS for mid-market legal teams; 40 integrations are listed, none produces pipeline, and the board asked which five partners actually matter.\nProgram today: Dozens of listed integrations, no depth strategy; demand data: A partner-source field on CRM opportunities; partnerships report to: Sales; executive sponsor: Interest but no budget; employees: 60\nThe business model supports partner-transacted deals: no; one platform dominates the customer base: no; partner-sourced revenue is a board metric: no; productizing integrations is the goal: no\nAttribution today: CRM partner-source field yes; one blended partner-touched number; claimed at close; caps set before the quarter no; window not given; AE comp equal on partner deals no; one forecast review yes\nHard deadline: no; a compounding asset; effort ceiling: medium; as-of: 2026-11-01",
 "partners": "Candidate partners (partner | evidence | blocked deals | joint economics | proposed rung | the page's rung):\n- Salesforce | evidence: 38% of customers run it; 9 lost deals in 2026 named the missing integration (numeric) | blocked deals $640k | joint economics unproven | proposed co-build | page rung cosell\n- DocuSign | evidence: 212 support requests a year for e-signature sync (numeric) | blocked deals $90k | joint economics unproven | proposed co-sell | page rung cosell\n- HubSpot | evidence: 14 open deals blocked on the connector (numeric) | blocked deals $310k | joint economics unproven | proposed co-sell | page rung cosell\n- Brieflyne AI | evidence: our CEO knows their founder (not demand evidence) | joint economics unproven | proposed co-build | page rung park\n- Slack | evidence: everyone uses it (not demand evidence) | joint economics unproven | proposed referral | page rung park\n\nCertification joins planned (platform | renewal owner | budget | cadence):\n- Salesforce AppExchange security review | renewal owner none | no budgeted hours | cadence annual",
 "carry": "",
 "facts": "The page's checks (5 fail, 2 warn, 0 pass, 4 n/a); verdict: partners picked on relationships - evidence first:\n- Portfolio and depth | shortlist | na | 5 partners: 3 with numeric evidence, 0 with a source but no numbers, 2 with none\n- Portfolio and depth | shape | na | Few-and-deep > Category-coverage breadth > Platform-anchor - dozens of listed integrations with no depth - concentrate on the few the evidence names\n- Portfolio and depth | evidence | fail | Brieflyne AI (\"our CEO knows their founder\" is not demand evidence); Slack (\"everyone uses it\" is not demand evidence) - parked until evidence exists\n- Portfolio and depth | graduation | fail | Salesforce proposed at co-build / strategic alliance - held at co-sell / integration alliance\n- Portfolio and depth | ladder | na | Co-sell / integration alliance > Referral > Co-build / strategic alliance > OEM / embed - the business model cannot support partner-transacted deals - the reseller rung is deleted, not parked\n- Certifications | renewals | fail | Salesforce AppExchange security review has no renewal owner and has no budgeted hours a quarter\n- Attribution | attribution | fail | one blended partner-touched number instead of sourced and influenced; attribution assigned at close instead of claimed at deal creation with a dated ID; no credit caps set before the quarter - uncapped influence is how partner revenue exceeds total\n\n[... 955 more characters cut from this display ...]"
}

Reply (long strings shortened for display - see the cuts below):

{
 "task": "portfolio",
 "summary": "Clausewick moves from 40 listed integrations to a few-and-deep portfolio of Salesforce, DocuSign and HubSpot at co-sell; first, name an owner and budgeted hours for the AppExchange security review before anything else is signed.",
 "portfolio": {
  "shape": "fewdeep",
  "why": "Concentrate on the three partners whose deals, requests and blocked pipeline are on record, run each as a co-sell motion, park Brieflyne AI and Slack, and stop maintaining the other listings as if they were partnerships."
 },
 "shortlist": [
  {
   "partner": "Salesforce",
   "evidence": "38% of customers run it; 9 lost deals in 2026 named the missing integration; $640k in blocked deals",
   "rung": "cosell",
   "next": "Moves to co-build once co-sold deals with Salesforce show proven joint economics, for example the first $640k of blocked pipeline closing with a Salesforce partner-source ID on each opportunity, alongside product, commercial and [... 17 more characters cut from this display]"
  },
  {
   "partner": "DocuSign",
   "evidence": "212 support requests a year for e-signature sync; $90k in blocked deals",
   "rung": "cosell",
   "next": "Moves to co-build once the maintained e-signature sync converts the $90k of blocked deals and the joint pipeline shows proven economics both sides sign off on."
  },
  {
   "partner": "HubSpot",
   "evidence": "14 open deals blocked on the connector; $310k in blocked deals",
   "rung": "cosell",
   "next": "Moves to co-build once the connector ships and a majority of the 14 blocked deals close as co-sold opportunities with proven joint economics."
  },
  {
   "partner": "Brieflyne AI",
   "evidence": "",
   "rung": "park",
   "next": "Un-parks only when CRM data names deals, request counts or a customer share for Brieflyne AI; the CEO's relationship with their founder does not count."
  },
  {
   "partner": "Slack",
   "evidence": "",
   "rung": "park",
   "next": "Un-parks when lost deals, support request counts or retention data tie a Slack integration to Clausewick revenue, not general usage."
  }
 ],
 "governance": [],
 "certifications": [
  {
   "platform": "Salesforce AppExchange security review",
   "owner": "Integration engineer (proposed)",
   "cost": "40 h a quarter (proposed)",
   "cadence": "annual"
  }
 ],
 "org": {
  "placement": "sales",
  "why": "Partnerships already report to Sales at 60 people, with no board metric on partner revenue and no productization goal, so the co-sell motions stay in the same pipeline and forecast as direct deals.",
  "roles": []
 },
 "kpis": [
  "Partner-sourced against partner-influenced revenue, reported as two numbers",
  "Activation rate: share of the three co-sell partners producing a lead or revenue each quarter",
  "Time to first co-sold deal per partner",
  "Partner CAC against direct CAC",
  "Blocked pipeline recovered: Salesforce $640k, HubSpot $310k, DocuSign $90k"
 ],
 "caveats": [
  "The AppExchange security review has no renewal owner and no budgeted hours today; do not sign until both are set.",
  "Attribution is one blended number assigned at close with no caps; the AE pay gap on partner deals will stall co-sell until fixed.",
  "The executive sponsor has interest but no budget; any later co-build step needs one."
 ]
}

Cut from this display only (the saved reply and the check use the full text): shortlist[0].next (245 characters, 228 shown).

What step 5 prints for it: Salesforce: cosell | DocuSign: cosell | HubSpot: cosell | Brieflyne AI: park | Slack: park

The page's check: kept - nothing to flag

attribution - A contract SaaS with 40 integrations and a vibes shortlist

The input carries the saved portfolio (R.laneForm fills carry from the portfolio reply), as the page's handoff does. Failing checks on the page: evidence, graduation, renewals, attribution, comp.

Input (facts is 2406 characters; the first 1397 are shown):

{
 "task": "attribution",
 "company": "Company: Clausewick\nThe product and what prompted this: Contract-management SaaS for mid-market legal teams; 40 integrations are listed, none produces pipeline, and the board asked which five partners actually matter.\nProgram today: Dozens of listed integrations, no depth strategy; demand data: A partner-source field on CRM opportunities; partnerships report to: Sales; executive sponsor: Interest but no budget; employees: 60\nThe business model supports partner-transacted deals: no; one platform dominates the customer base: no; partner-sourced revenue is a board metric: no; productizing integrations is the goal: no\nAttribution today: CRM partner-source field yes; one blended partner-touched number; claimed at close; caps set before the quarter no; window not given; AE comp equal on partner deals no; one forecast review yes\nHard deadline: no; a compounding asset; effort ceiling: medium; as-of: 2026-11-01",
 "partners": "Candidate partners (partner | evidence | blocked deals | joint economics | proposed rung | the page's rung):\n- Salesforce | evidence: 38% of customers run it; 9 lost deals in 2026 named the missing integration (numeric) | blocked deals $640k | joint economics unproven | proposed co-build | page rung cosell\n- DocuSign | evidence: 212 support requests a year for e-signature sync (numeric) | blocked deals $90k | joint economics unproven | proposed co-sell | page rung cosell\n- HubSpot | evidence: 14 open deals blocked on the connector (numeric) | blocked deals $310k | joint economics unproven | proposed co-sell | page rung cosell\n- Brieflyne AI | evidence: our CEO knows their founder (not demand evidence) | joint economics unproven | proposed co-build | page rung park\n- Slack | evidence: everyone uses it (not demand evidence) | joint economics unproven | proposed referral | page rung park\n\nCertification joins planned (platform | renewal owner | budget | cadence):\n- Salesforce AppExchange security review | renewal owner none | no budgeted hours | cadence annual",
 "carry": "Portfolio: Few-and-deep - Concentrate on the three partners whose deals, requests and blocked pipeline are on record, run each as a co-sell motion, park Brieflyne AI and Slack, and stop maintaining the other listings as if they were partnerships.\nRungs: Salesforce co-sell / integration alliance; DocuSign co-sell / integration alliance; HubSpot co-sell / integration alliance; Brieflyne AI parked - no demand evidence; Slack parked - no demand evidence\nThe function: Report into Sales",
 "facts": "The page's checks (5 fail, 2 warn, 0 pass, 4 n/a); verdict: partners picked on relationships - evidence first:\n- Portfolio and depth | shortlist | na | 5 partners: 3 with numeric evidence, 0 with a source but no numbers, 2 with none\n- Portfolio and depth | shape | na | Few-and-deep > Category-coverage breadth > Platform-anchor - dozens of listed integrations with no depth - concentrate on the few the evidence names\n- Portfolio and depth | evidence | fail | Brieflyne AI (\"our CEO knows their founder\" is not demand evidence); Slack (\"everyone uses it\" is not demand evidence) - parked until evidence exists\n- Portfolio and depth | graduation | fail | Salesforce proposed at co-build / strategic alliance - held at co-sell / integration alliance\n- Portfolio and depth | ladder | na | Co-sell / integration alliance > Referral > Co-build / strategic alliance > OEM / embed - the business model cannot support partner-transacted deals - the reseller rung is deleted, not parked\n- Certifications | renewals | fail | Salesforce AppExchange security review has no renewal owner and has no budgeted hours a quarter\n- Attribution | attribution | fail | one blended partner-touched number instead of sourced and influenced; attribution assigned at close instead of claimed at deal creation with a dated ID; no credit caps set before the quarter - uncapped influence is how partner revenue exceeds total\n\n[... 1009 more characters cut from this display ...]"
}

Reply:

{
 "task": "attribution",
 "summary": "Clausewick replaces its one blended partner-touched number, assigned at close, with capped sourced and influenced credit claimed at deal creation on the Salesforce, DocuSign and HubSpot co-sell motions, and equal AE pay.",
 "definitions": {
  "sourced": "A Clausewick opportunity counts as sourced when Salesforce, DocuSign or HubSpot brought the legal-team buyer and the deal would not exist without that partner.",
  "influenced": "An opportunity counts as influenced when the deal was already open and a partner materially advanced it, for example HubSpot unblocking one of the 14 connector-blocked deals."
 },
 "claim": {
  "field": "Add a required Partner Source picklist on the CRM opportunity, limited to the three co-sell partners, paired with a Partner Claim ID stamped with the claim date.",
  "timing": "The partner claim is entered when the opportunity is created and locked after the window, never added or changed at close.",
  "window": "14 days (proposed)"
 },
 "caps": {
  "sourced": "Partner-sourced credit is capped at 25% of new bookings per quarter (proposed), set in the plan before the quarter opens.",
  "influenced": "Partner-influenced credit is capped at 40% of new bookings per quarter (proposed), reported as its own number and never added to sourced."
 },
 "motions": [
  {
   "rung": "cosell",
   "rule": "A co-sell deal carries one sourced partner per deal, chosen from Salesforce, DocuSign or HubSpot at creation, while any other of the three that advanced it is logged as influenced only."
  }
 ],
 "comp": "AEs earn the same quota credit and commission rate on a Salesforce, DocuSign or HubSpot co-sell deal as on a direct deal, closing today's gap where partner deals pay less.",
 "forecast": "Co-sell opportunities sit in the existing weekly forecast review with the same stage exit criteria as direct deals, flagged by the Partner Source field rather than tracked apart.",
 "kpis": [
  "Partner-sourced against partner-influenced revenue, quarter by quarter",
  "Activation rate: share of the three co-sell partners producing a lead or revenue",
  "Time to first deal per co-sell partner",
  "Partner CAC against direct CAC",
  "Share of the $1.04M blocked pipeline recovered"
 ],
 "caveats": [
  "The caps and the 14-day window are proposed; Sales leadership should confirm them before next quarter starts.",
  "The equal-comp change needs a budget, and the sponsor today has interest but none.",
  "Brieflyne AI and Slack are parked and get no attribution rule until demand evidence exists."
 ]
}

What step 5 prints for it: cosell: A co-sell deal carries one sourced partner per deal, chosen from Salesforce, DocuSign or HubSpot at creation, while any other of the three that advanced it is logged as influenced only.

The page's check: kept - nothing to flag

portfolio - A field-service platform with a program that holds

The page read it as: a partnership portfolio finance and partners can both trust; portfolio fewdeep, breadth, anchor; org alliances, sales, product; rungs QuickBooks cobuild, ServiceTitan Pay cosell, Google Calendar cosell, Angi Leads referral; 5 of 5 gates; failing checks: none.

Input (facts is 2163 characters; the first 1399 are shown):

{
 "task": "portfolio",
 "company": "Company: Coilwright\nThe product and what prompted this: A field-service management platform for HVAC and electrical contractors, re-evaluating a program that grew partner by partner.\nProgram today: A mature program being re-evaluated; demand data: A partner-source field on CRM opportunities; partnerships report to: A dedicated BD or Alliances org; executive sponsor: Yes, with budget; employees: 240\nThe business model supports partner-transacted deals: no; one platform dominates the customer base: no; partner-sourced revenue is a board metric: yes; productizing integrations is the goal: no\nAttribution today: CRM partner-source field yes; sourced and influenced reported separately; claimed at creation; caps set before the quarter yes; window 14 days; AE comp equal on partner deals yes; one forecast review yes\nHard deadline: no; a compounding asset; effort ceiling: high; as-of: 2026-11-01",
 "partners": "Candidate partners (partner | evidence | blocked deals | joint economics | proposed rung | the page's rung):\n- QuickBooks | evidence: 61% of accounts sync invoices; partner-sourced $1.2M pipeline in 4 quarters (numeric) | blocked deals $480k | joint economics proven | proposed co-build | page rung cobuild\n- ServiceTitan Pay | evidence: 27 deals in 2026 cited payments; retention 9 points higher with payments on (numeric) | blocked deals $220k | joint economics unproven | proposed co-sell | page rung cosell\n- Google Calendar | evidence: 1,100 accounts connected; 3 lost deals named scheduling (numeric) | joint economics unproven | proposed co-sell | page rung cosell\n- Angi Leads | evidence: 46 requests from CS in two quarters (numeric) | joint economics unproven | proposed referral | page rung referral\n\nCertification joins planned (platform | renewal owner | budget | cadence):\n- Intuit App Partner Program | renewal owner Integrations PM | 60 h a quarter | cadence annual\n- Google Workspace Marketplace verification | renewal owner Partner engineer | 24 h a quarter | cadence annual",
 "carry": "",
 "facts": "The page's checks (0 fail, 0 warn, 6 pass, 5 n/a); verdict: a partnership portfolio finance and partners can both trust:\n- Portfolio and depth | shortlist | na | 4 partners: 4 with numeric evidence, 0 with a source but no numbers, 0 with none\n- Portfolio and depth | shape | na | Few-and-deep > Category-coverage breadth > Platform-anchor\n- Portfolio and depth | evidence | pass | every partner names deals, requests, customers or retention\n- Portfolio and depth | graduation | pass | QuickBooks at co-build / strategic alliance - joint economics proven\n- Portfolio and depth | ladder | na | Co-build / strategic alliance > Co-sell / integration alliance > Referral > OEM / embed - the business model cannot support partner-transacted deals - the reseller rung is deleted, not parked; a compounding mandate with proven joint economics promotes co-build\n- Certifications | renewals | pass | Intuit App Partner Program - Integrations PM, 60 h a quarter; Google Workspace Marketplace verification - Partner engineer, 24 h a quarter\n- Attribution | attribution | pass | a CRM partner-source field, two capped numbers, claimed at creation\n- Attribution | window | pass | 14 days\n- Attribution | comp | pass | comp equalized and one forecast review\n- The function | org | na | A standalone Alliances org > Report into Sales > Integrations under Product - partner-sourced revenue is a board metric and deep\n\n[... 764 more characters cut from this display ...]"
}

Reply (long strings shortened for display - see the cuts below):

{
 "task": "portfolio",
 "summary": "Coilwright runs a few-and-deep portfolio led by a QuickBooks co-build, with ServiceTitan Pay and Google Calendar at co-sell and Angi Leads at referral; first, put QuickBooks under a joint business plan and quarterly QBRs.",
 "portfolio": {
  "shape": "fewdeep",
  "why": "Graduate QuickBooks to co-build on its proven joint economics, keep ServiceTitan Pay and Google Calendar as maintained co-sell integrations, hold Angi Leads at referral, and drop the reseller rung since partner-transacted deals do not fit [... 11 more characters cut from this display]"
 },
 "shortlist": [
  {
   "partner": "QuickBooks",
   "evidence": "61% of accounts sync invoices; partner-sourced $1.2M pipeline in 4 quarters; $480k in blocked deals",
   "rung": "cobuild",
   "next": "Moves toward OEM only if the co-build delivers its dated joint targets for consecutive quarters and both sides show product, commercial and operational fit for an embedded offer."
  },
  {
   "partner": "ServiceTitan Pay",
   "evidence": "27 deals in 2026 cited payments; retention 9 points higher with payments on; $220k in blocked deals",
   "rung": "cosell",
   "next": "Moves to co-build once co-sold payments deals, starting with the $220k blocked, show proven joint economics tracked through the partner-source field."
  },
  {
   "partner": "Google Calendar",
   "evidence": "1,100 accounts connected; 3 lost deals named scheduling",
   "rung": "cosell",
   "next": "Moves to co-build once the scheduling integration produces partner-sourced pipeline with joint economics proven against the 3 lost deals' profile."
  },
  {
   "partner": "Angi Leads",
   "evidence": "46 requests from CS in two quarters",
   "rung": "referral",
   "next": "Moves to co-sell once referrals turn into named, partner-sourced deals in the CRM rather than CS requests alone."
  }
 ],
 "governance": [
  {
   "partner": "QuickBooks",
   "cadence": "monthly sync, quarterly QBR (proposed)",
   "plan": "Shared dated targets of growing invoice-sync adoption past 61% of accounts and recovering the $480k blocked pipeline by 2027-06-30 (proposed), with Coilwright carrying the heavier engineering lift now.",
   "qbr": "Coilwright's Alliances lead and Integrations PM plus a QuickBooks partner leader who can commit resources review last quarter's commitments and set the next quarter's."
  }
 ],
 "certifications": [
  {
   "platform": "Intuit App Partner Program",
   "owner": "Integrations PM",
   "cost": "60 h a quarter",
   "cadence": "annual"
  },
  {
   "platform": "Google Workspace Marketplace verification",
   "owner": "Partner engineer",
   "cost": "24 h a quarter",
   "cadence": "annual"
  }
 ],
 "org": {
  "placement": "alliances",
  "why": "Partner-sourced revenue is a board metric and the QuickBooks co-build needs a dedicated owner, so the existing Alliances org with a budgeted sponsor keeps the function.",
  "roles": [
   "Partner managers",
   "Partner or integration engineer",
   "Integration product manager",
   "Top 10-15 partners run as named accounts"
  ]
 },
 "kpis": [
  "Partner-sourced against partner-influenced revenue on the board dashboard",
  "Activation rate across the four signed partners",
  "Time to first deal for ServiceTitan Pay, Google Calendar and Angi Leads",
  "Partner CAC against direct CAC",
  "QuickBooks joint-plan targets hit per quarter"
 ],
 "caveats": [
  "The QuickBooks joint business plan targets and dates are proposed; confirm them with QuickBooks at the first QBR."
 ]
}

Cut from this display only (the saved reply and the check use the full text): portfolio.why (249 characters, 238 shown).

What step 5 prints for it: QuickBooks: cobuild | ServiceTitan Pay: cosell | Google Calendar: cosell | Angi Leads: referral

The page's check: kept - nothing to flag

Build the input yourself

Load the engine in node (global.window = global; require("./pfkit.js"); require("./pfreply.js")), then:

const K = PartnerKit, R = PartnerReply;
const f = K.form(Object.assign(K.blank(), { name: "Acme", split: "blended", window: "14",
  partners: "HubSpot | 14 open deals blocked | $310k | no | co-sell\nZoomInfo | our CEO knows them | | no | co-build" }));
// f.partnerRows (each with kind, rec and why), f.shapeRank, f.ladderRank, f.orgRank (the ranked menus), f.gates
// K.scorecardCsv(f), K.rulesMd(f) - the scorecard and the attribution rules draft
const b = K.buildInput(f, "portfolio");                      // or "attribution" (R.laneForm(form, "attribution", portfolio) fills carry)
const wire = K.toWire(b.input);                              // POST this to /estimate and /run
// then: const reply = R.normalize(R.parseReply(job.output.output), "portfolio");
// R.check(reply, b)                                         // {status: kept or flagged, notes}

Get a token for the steps below from /tokens.html.

Step 1 — a tiny client helper

One function that sends JSON and unwraps the response. Paste a personal token from /tokens.html, or leave it empty and mint a guest token in step 2.

BASE="https://api.skillsafe.ai/v1/app-api"
TOKEN="YOUR_TOKEN"   # from https://partner-fit.skillsafe.ai/tokens.html
api() { # api METHOD PATH [JSON-BODY]
  curl -s -X "$1" "$BASE$2" -H "Content-Type: application/json" \
    ${TOKEN:+-H "Authorization: Bearer $TOKEN"} ${3:+--data "$3"}
}

import json, urllib.request

BASE = "https://api.skillsafe.ai/v1/app-api"
TOKEN = "YOUR_TOKEN"  # from https://partner-fit.skillsafe.ai/tokens.html

def api(method, path, body=None, headers=None):
    req = urllib.request.Request(BASE + path, method=method,
        data=None if body is None else json.dumps(body).encode(),
        headers={"Content-Type": "application/json", **({"Authorization": "Bearer " + TOKEN} if TOKEN else {}), **(headers or {})})
    with urllib.request.urlopen(req) as r:
        env = json.load(r)
    if env.get("error"):
        raise RuntimeError(env["error"])
    return env["data"]

// partner-fit.mjs -- Node 18+ (global fetch)
const BASE = "https://api.skillsafe.ai/v1/app-api";
let TOKEN = "YOUR_TOKEN"; // from https://partner-fit.skillsafe.ai/tokens.html
async function api(method, path, body, headers = {}) {
  const r = await fetch(BASE + path, { method, headers: { "Content-Type": "application/json",
    ...(TOKEN ? { Authorization: "Bearer " + TOKEN } : {}), ...headers },
    body: body === undefined ? undefined : JSON.stringify(body) });
  const env = await r.json();
  if (env.error) throw new Error(env.error.code + ": " + env.error.message);
  return env.data;
}

package main

import ("bytes"; "encoding/json"; "fmt"; "net/http")

const base = "https://api.skillsafe.ai/v1/app-api"
var token = "YOUR_TOKEN" // from https://partner-fit.skillsafe.ai/tokens.html

func api(method, path string, body any, headers map[string]string) (map[string]any, error) {
	var buf bytes.Buffer
	if body != nil { json.NewEncoder(&buf).Encode(body) }
	req, _ := http.NewRequest(method, base+path, &buf)
	req.Header.Set("Content-Type", "application/json")
	if token != "" { req.Header.Set("Authorization", "Bearer "+token) }
	for k, v := range headers { req.Header.Set(k, v) }
	res, err := http.DefaultClient.Do(req)
	if err != nil { return nil, err }
	defer res.Body.Close()
	var env struct { Data map[string]any; Error map[string]any }
	json.NewDecoder(res.Body).Decode(&env)
	if env.Error != nil { return nil, fmt.Errorf("%v", env.Error) }
	return env.Data, nil
}

// Partner Fit.java -- Java 17+, with com.fasterxml.jackson.core:jackson-databind
import com.fasterxml.jackson.databind.*;
import java.net.URI; import java.net.http.*; import java.util.*;

public class Partner Fit {
  static final String BASE = "https://api.skillsafe.ai/v1/app-api";
  static String token = "YOUR_TOKEN"; // from https://partner-fit.skillsafe.ai/tokens.html
  static final ObjectMapper M = new ObjectMapper();
  static final HttpClient C = HttpClient.newHttpClient();
  static JsonNode api(String method, String path, Object body, Map<String, String> headers) throws Exception {
    var b = HttpRequest.newBuilder(URI.create(BASE + path)).header("Content-Type", "application/json");
    if (!token.isEmpty()) b.header("Authorization", "Bearer " + token);
    if (headers != null) headers.forEach(b::header);
    b.method(method, body == null ? HttpRequest.BodyPublishers.noBody() : HttpRequest.BodyPublishers.ofString(M.writeValueAsString(body)));
    JsonNode env = M.readTree(C.send(b.build(), HttpResponse.BodyHandlers.ofString()).body());
    if (env.hasNonNull("error")) throw new RuntimeException(env.get("error").toString());
    return env.get("data");
  }
}

require "json"
require "net/http"

BASE = "https://api.skillsafe.ai/v1/app-api"
TOKEN = "YOUR_TOKEN" # from https://partner-fit.skillsafe.ai/tokens.html

def api(method, path, body = nil, headers = {})
  uri = URI(BASE + path)
  req = Net::HTTPGenericRequest.new(method, !body.nil?, true, uri.request_uri,
    { "Content-Type" => "application/json" }.merge(TOKEN.empty? ? {} : { "Authorization" => "Bearer #{TOKEN}" }).merge(headers))
  req.body = JSON.generate(body) unless body.nil?
  env = JSON.parse(Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }.body)
  raise env["error"].to_s if env["error"]
  env["data"]
end

<?php
const BASE = "https://api.skillsafe.ai/v1/app-api";
$TOKEN = "YOUR_TOKEN"; // from https://partner-fit.skillsafe.ai/tokens.html

function api(string $method, string $path, $body = null, array $headers = []) {
    global $TOKEN;
    $h = ["Content-Type: application/json"];
    if ($TOKEN) $h[] = "Authorization: Bearer $TOKEN";
    foreach ($headers as $k => $v) $h[] = "$k: $v";
    $ch = curl_init(BASE . $path);
    curl_setopt_array($ch, [CURLOPT_CUSTOMREQUEST => $method, CURLOPT_HTTPHEADER => $h, CURLOPT_RETURNTRANSFER => true]);
    if ($body !== null) curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
    $env = json_decode(curl_exec($ch), true);
    if (!empty($env["error"])) throw new Exception(json_encode($env["error"]));
    return $env["data"];
}

// Program.cs -- .NET 6+ console app
using System.Net.Http.Json; using System.Text.Json; using System.Text.Json.Nodes;

static class Api {
  public const string Base = "https://api.skillsafe.ai/v1/app-api";
  public static string Token = "YOUR_TOKEN"; // from https://partner-fit.skillsafe.ai/tokens.html
  static readonly HttpClient C = new();
  public static async Task<JsonNode?> Call(string method, string path, object? body = null, Dictionary<string, string>? headers = null) {
    var req = new HttpRequestMessage(new HttpMethod(method), Base + path);
    if (Token != "") req.Headers.Add("Authorization", "Bearer " + Token);
    if (headers != null) foreach (var h in headers) req.Headers.Add(h.Key, h.Value);
    if (body != null) req.Content = JsonContent.Create(body);
    var env = JsonNode.Parse(await (await C.SendAsync(req)).Content.ReadAsStringAsync())!;
    if (env["error"] is JsonNode e && e.GetValueKind() != JsonValueKind.Null) throw new Exception(e.ToJsonString());
    return env["data"];
  }
}

Step 2 — a token

A guest token is enough for /me and /estimate. A run is metered, so it needs a personal token: sign in on /tokens.html and copy it from there.

# a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
TOKEN=$(curl -s -X POST "$BASE/guest" -H "Content-Type: application/json" -d '{"slug":"partner-fit"}' | jq -r '.data.token')

# a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
TOKEN = ""
TOKEN = api("POST", "/guest", {"slug": "partner-fit"})["token"]

// a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
TOKEN = "";
TOKEN = (await api("POST", "/guest", { slug: "partner-fit" })).token;

// inside main: a guest token (enough for /me and /estimate); a run needs your personal token
token = ""
g, err := api("POST", "/guest", map[string]string{"slug": "partner-fit"}, nil)
if err != nil { panic(err) }
token = g["token"].(string)

// inside main: a guest token (enough for /me and /estimate); a run needs your personal token
token = "";
token = api("POST", "/guest", Map.of("slug", "partner-fit"), null).get("token").asText();

# a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
TOKEN.replace("")
TOKEN.replace(api("POST", "/guest", { slug: "partner-fit" })["token"])

// a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
$TOKEN = "";
$TOKEN = api("POST", "/guest", ["slug" => "partner-fit"])["token"];

// a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
Api.Token = "";
Api.Token = (await Api.Call("POST", "/guest", new { slug = "partner-fit" }))!["token"]!.GetValue<string>();

Step 3 — GET /me

Who the token is (subject_type: user or guest) and the credit balance.

api GET /me | jq '.data | {subject_type, credits}' 

me = api("GET", "/me")
print(me["subject_type"], me.get("credits"))

const me = await api("GET", "/me");
console.log(me.subject_type, me.credits);

me, _ := api("GET", "/me", nil, nil)
fmt.Println(me["subject_type"], me["credits"])

JsonNode me = api("GET", "/me", null, null);
System.out.println(me.get("subject_type") + " " + me.get("credits"));

me = api("GET", "/me")
puts [me["subject_type"], me["credits"]].inspect

$me = api("GET", "/me");
echo $me["subject_type"], " ", $me["credits"] ?? "", "\n";

var me = await Api.Call("GET", "/me");
Console.WriteLine($"{me!["subject_type"]} {me["credits"]}");

Step 4 — POST /estimate

Free. The body is the run input itself, the bare object (never wrapped in {"input": ...}). hold_credits is a reservation, not the price; min_credits is what the balance must cover; model_alias reads gpt-terra.

# input.json: the run input object - {"task": "portfolio", "company": "Company: Clausewick
The product and what prompted this: ...", "partners": "Candidate partners (partner | evidence | ...):
- Salesforce | evidence: 38% of customers run it ...", "carry": "", "facts": "The page's checks (...); verdict: partners picked on relationships - evidence first:
- Portfolio and depth | evidence | fail | ..."}
# - see the input table
api POST /estimate "$(cat input.json)" | jq '.data | {hold_credits, min_credits, model, model_alias, markup_bps, warnings}' 

inp = json.load(open("input.json"))   # {"task": "portfolio", "company": "Company: Clausewick
The product and what prompted this: ...", "partners": "Candidate partners (partner | evidence | ...):
- Salesforce | evidence: 38% of customers run it ...", "carry": "", "facts": "The page's checks (...); verdict: partners picked on relationships - evidence first:
- Portfolio and depth | evidence | fail | ..."}
# - see the input table
est = api("POST", "/estimate", inp)
print(est["hold_credits"], est["min_credits"], est["model"], est.get("warnings"))

import { readFileSync } from "node:fs";
const input = JSON.parse(readFileSync("input.json", "utf8")); // {task: "portfolio" or "attribution", company, partners, carry, facts} (see the input table)
const est = await api("POST", "/estimate", input);
console.log(est.hold_credits, est.min_credits, est.model, est.warnings);

raw, _ := os.ReadFile("input.json") // add "os" to the imports
var input map[string]any
json.Unmarshal(raw, &input)
est, _ := api("POST", "/estimate", input, nil)
fmt.Println(est["hold_credits"], est["min_credits"], est["model"])

Map<String, Object> input = M.readValue(new java.io.File("input.json"), Map.class);
JsonNode est = api("POST", "/estimate", input, null);
System.out.println(est.get("hold_credits") + " " + est.get("min_credits") + " " + est.get("model"));

input = JSON.parse(File.read("input.json"))
est = api("POST", "/estimate", input)
puts [est["hold_credits"], est["min_credits"], est["model"]].inspect

$input = json_decode(file_get_contents("input.json"), true);
$est = api("POST", "/estimate", $input);
echo $est["hold_credits"], " ", $est["min_credits"], " ", $est["model"], "\n";

var input = JsonNode.Parse(File.ReadAllText("input.json"))!;
var est = await Api.Call("POST", "/estimate", input);
Console.WriteLine($"{est!["hold_credits"]} {est["min_credits"]} {est["model"]}");

Step 5 — POST /run, then poll the job

Send an Idempotency-Key built from the lane and the input: a retry with the same key never bills twice. The page uses partner-fit:<task>:<inputHash>:a<attempt> - the lane is part of the key, retry_note is left out of the hash - and its one automatic reformat retry is a new attempt number, named in the page as one extra run. A portfolio reply carries summary, portfolio, shortlist, governance, certifications, org, kpis and caveats; an attribution reply carries summary, definitions, claim, caps, motions, comp, forecast, kpis and caveats. The code below prints the gist of either: each partner and its rung, or each motion and its rule.

KEY="partner-fit:$(jq -r .task input.json):$(shasum -a 256 input.json | cut -c1-16):a1"
JOB=$(curl -s -X POST "$BASE/run" -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \
  -H "Idempotency-Key: $KEY" --data @input.json | jq -r '.data.job_id')
while :; do
  J=$(api GET "/jobs/$JOB"); S=$(echo "$J" | jq -r '.data.status')
  case "$S" in succeeded|failed|cancelled) break;; esac; sleep 2
done
echo "$J" | jq -r '.data.output.output' > reply.json   # one JSON object, the reply contract
echo "$J" | jq '.data | {charged_credits, truncated}'
jq -r 'if .task == "attribution" then (.motions[] | "\(.rung): \(.rule)") 
       else (.shortlist[] | "\(.partner): \(.rung)") end' reply.json

import hashlib, time
key = "partner-fit:" + inp["task"] + ":" + hashlib.sha256(json.dumps(inp).encode()).hexdigest()[:16] + ":a1"
job = api("POST", "/run", inp, {"Idempotency-Key": key})
while True:
    j = api("GET", "/jobs/" + job["job_id"])
    if j["status"] in ("succeeded", "failed", "cancelled"):
        break
    time.sleep(2)
reply = json.loads(j["output"]["output"])  # the reply as one JSON object
print(j["charged_credits"], j.get("truncated"), reply["task"])
if reply["task"] == "attribution":
    for x in reply["motions"]:
        print(x["rung"], x["rule"])
else:
    for x in reply["shortlist"]:
        print(x["partner"], x["rung"])

import { createHash } from "node:crypto";
const key = `partner-fit:${input.task}:${createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 16)}:a1`;
const job = await api("POST", "/run", input, { "Idempotency-Key": key });
let j;
do { await new Promise((r) => setTimeout(r, 2000)); j = await api("GET", "/jobs/" + job.job_id); }
while (!["succeeded", "failed", "cancelled"].includes(j.status));
const reply = JSON.parse(j.output.output);
console.log(j.charged_credits, j.truncated, reply.task);
if (reply.task === "attribution") { for (const x of reply.motions) console.log(x.rung, x.rule); }
else { for (const x of reply.shortlist) console.log(x.partner, x.rung); }

sum := sha256.Sum256(raw) // add "crypto/sha256", "encoding/hex", "time" to the imports
key := "partner-fit:" + input["task"].(string) + ":" + hex.EncodeToString(sum[:8]) + ":a1"
job, _ := api("POST", "/run", input, map[string]string{"Idempotency-Key": key})
var j map[string]any
for {
	time.Sleep(2 * time.Second)
	j, _ = api("GET", "/jobs/"+job["job_id"].(string), nil, nil)
	if s := j["status"]; s == "succeeded" || s == "failed" || s == "cancelled" { break }
}
var reply map[string]any
json.Unmarshal([]byte(j["output"].(map[string]any)["output"].(string)), &reply)
fmt.Println(j["charged_credits"], j["truncated"], reply["task"])
key, a, b := "shortlist", "partner", "rung"
if reply["task"] == "attribution" {
	key, a, b = "motions", "rung", "rule"
}
xs, _ := reply[key].([]any)
for _, x := range xs {
	xx := x.(map[string]any)
	fmt.Println(xx[a], xx[b])
}

var digest = java.security.MessageDigest.getInstance("SHA-256").digest(M.writeValueAsBytes(input));
String key = "partner-fit:" + input.get("task") + ":" + HexFormat.of().formatHex(digest, 0, 8) + ":a1";
JsonNode job = api("POST", "/run", input, Map.of("Idempotency-Key", key)), j;
do { Thread.sleep(2000); j = api("GET", "/jobs/" + job.get("job_id").asText(), null, null); }
while (!Set.of("succeeded", "failed", "cancelled").contains(j.get("status").asText()));
JsonNode reply = M.readTree(j.get("output").get("output").asText());
System.out.println(j.get("charged_credits") + " " + reply.path("task").asText());
if (reply.path("task").asText().equals("attribution")) {
  for (JsonNode x : reply.path("motions")) System.out.println(x.path("rung").asText() + " " + x.path("rule").asText());
} else {
  for (JsonNode x : reply.path("shortlist")) System.out.println(x.path("partner").asText() + " " + x.path("rung").asText());
}

require "digest"
key = "partner-fit:#{input["task"]}:#{Digest::SHA256.hexdigest(JSON.generate(input))[0, 16]}:a1"
job = api("POST", "/run", input, { "Idempotency-Key" => key })
j = nil
loop do
  sleep 2
  j = api("GET", "/jobs/#{job["job_id"]}")
  break if %w[succeeded failed cancelled].include?(j["status"])
end
reply = JSON.parse(j["output"]["output"])
puts [j["charged_credits"], j["truncated"], reply["task"]].inspect
if reply["task"] == "attribution"
  reply["motions"].each { |x| puts "#{x["rung"]} #{x["rule"]}" }
else
  reply["shortlist"].each { |x| puts "#{x["partner"]} #{x["rung"]}" }
end

$key = "partner-fit:" . $input["task"] . ":" . substr(hash("sha256", json_encode($input)), 0, 16) . ":a1";
$job = api("POST", "/run", $input, ["Idempotency-Key" => $key]);
do { sleep(2); $j = api("GET", "/jobs/" . $job["job_id"]); }
while (!in_array($j["status"], ["succeeded", "failed", "cancelled"]));
$reply = json_decode($j["output"]["output"], true);
echo $j["charged_credits"], " ", $reply["task"], "\n";
if ($reply["task"] === "attribution") { foreach ($reply["motions"] as $x) echo $x["rung"], " ", $x["rule"], "\n"; }
else { foreach ($reply["shortlist"] as $x) echo $x["partner"], " ", $x["rung"], "\n"; }

var digest = System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(input.ToJsonString()));
var key = $"partner-fit:{input["task"]}:{Convert.ToHexString(digest, 0, 8).ToLowerInvariant()}:a1";
var job = await Api.Call("POST", "/run", input, new() { ["Idempotency-Key"] = key });
JsonNode j;
do { await Task.Delay(2000); j = (await Api.Call("GET", "/jobs/" + job!["job_id"]))!; }
while (!new[] { "succeeded", "failed", "cancelled" }.Contains(j["status"]!.GetValue<string>()));
var reply = JsonNode.Parse(j["output"]!["output"]!.GetValue<string>())!;
var task = (string?)reply["task"];
Console.WriteLine($"{j["charged_credits"]} {task}");
if (task == "attribution") { foreach (var x in reply["motions"]!.AsArray()) Console.WriteLine($"{x!["rung"]} {x["rule"]}"); }
else { foreach (var x in reply["shortlist"]!.AsArray()) Console.WriteLine($"{x!["partner"]} {x["rung"]}"); }

Step 6 — POST /run-stream

The same run as Server-Sent Events, with the same input.json. Browsers receive progress ticks rather than text deltas; the final done event carries the reply.

# Server-Sent Events: tick/delta events while the job runs, then a final event with the job
curl -N -s -X POST "$BASE/run-stream" -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \
  -H "Idempotency-Key: partner-fit:$(jq -r .task input.json):$(shasum -a 256 input.json | cut -c1-16):a1" --data @input.json

rev = json.load(open("input.json"))  # the same run input as input.json: {"task": "portfolio", "company": "Company: Clausewick
The product and what prompted this: ...", "partners": "Candidate partners (partner | evidence | ...):
- Salesforce | evidence: 38% of customers run it ...", "carry": "", "facts": "The page's checks (...); verdict: partners picked on relationships - evidence first:
- Portfolio and depth | evidence | fail | ..."}
# - see the input table
req = urllib.request.Request(BASE + "/run-stream", method="POST", data=json.dumps(rev).encode(),
    headers={"Content-Type": "application/json", "Authorization": "Bearer " + TOKEN,
             "Idempotency-Key": "partner-fit:" + rev["task"] + ":" + hashlib.sha256(json.dumps(rev).encode()).hexdigest()[:16] + ":a1"})
with urllib.request.urlopen(req) as r:
    for line in r:
        line = line.decode().strip()
        if line.startswith("data:"):
            print(line[5:].strip()[:200])

const rev = JSON.parse(readFileSync("input.json", "utf8"));
const r = await fetch(BASE + "/run-stream", { method: "POST", body: JSON.stringify(rev), headers: {
  "Content-Type": "application/json", Authorization: "Bearer " + TOKEN,
  "Idempotency-Key": `partner-fit:${rev.task}:${createHash("sha256").update(JSON.stringify(rev)).digest("hex").slice(0, 16)}:a1` } });
const dec = new TextDecoder();
for await (const chunk of r.body) for (const line of dec.decode(chunk).split("\n"))
  if (line.startsWith("data:")) console.log(line.slice(5).trim().slice(0, 200));

rraw, _ := os.ReadFile("input.json") // add "bufio", "strings" to the imports
rs := sha256.Sum256(rraw)
req, _ := http.NewRequest("POST", base+"/run-stream", bytes.NewReader(rraw))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Idempotency-Key", "partner-fit:"+input["task"].(string)+":"+hex.EncodeToString(rs[:8])+":a1")
res, _ := http.DefaultClient.Do(req)
sc := bufio.NewScanner(res.Body)
for sc.Scan() { if l := sc.Text(); strings.HasPrefix(l, "data:") { fmt.Println(l[5:]) } }

String rev = java.nio.file.Files.readString(java.nio.file.Path.of("input.json"));
var rd = java.security.MessageDigest.getInstance("SHA-256").digest(rev.getBytes());
var sreq = HttpRequest.newBuilder(URI.create(BASE + "/run-stream")).header("Content-Type", "application/json")
  .header("Authorization", "Bearer " + token).header("Idempotency-Key", "partner-fit:" + input.get("task") + ":" + HexFormat.of().formatHex(rd, 0, 8) + ":a1")
  .POST(HttpRequest.BodyPublishers.ofString(rev)).build();
C.send(sreq, HttpResponse.BodyHandlers.ofLines()).body().filter(l -> l.startsWith("data:")).forEach(System.out::println);

rev = File.read("input.json")
uri = URI(BASE + "/run-stream")
req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json", "Authorization" => "Bearer #{TOKEN}",
  "Idempotency-Key" => "partner-fit:#{JSON.parse(rev)["task"]}:#{Digest::SHA256.hexdigest(rev)[0, 16]}:a1")
req.body = rev
Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |h|
  h.request(req) { |res| res.read_body { |chunk| chunk.each_line { |l| puts l if l.start_with?("data:") } } }
end

$rev = file_get_contents("input.json");
$ch = curl_init(BASE . "/run-stream");
curl_setopt_array($ch, [CURLOPT_POST => true, CURLOPT_POSTFIELDS => $rev, CURLOPT_HTTPHEADER => [
    "Content-Type: application/json", "Authorization: Bearer $TOKEN",
    "Idempotency-Key: partner-fit:" . json_decode($rev, true)["task"] . ":" . substr(hash("sha256", $rev), 0, 16) . ":a1"],
    CURLOPT_WRITEFUNCTION => function ($ch, $chunk) { foreach (explode("\n", $chunk) as $l) if (str_starts_with($l, "data:")) echo $l, "\n"; return strlen($chunk); }]);
curl_exec($ch);

var rev = File.ReadAllText("input.json");
var rd = System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(rev));
var sreq = new HttpRequestMessage(HttpMethod.Post, Api.Base + "/run-stream") { Content = new StringContent(rev, System.Text.Encoding.UTF8, "application/json") };
sreq.Headers.Add("Authorization", "Bearer " + Api.Token);
sreq.Headers.Add("Idempotency-Key", $"partner-fit:{input["task"]}:{Convert.ToHexString(rd, 0, 8).ToLowerInvariant()}:a1");
using var http = new HttpClient();
using var res = await http.SendAsync(sreq, HttpCompletionOption.ResponseHeadersRead);
using var rdr = new StreamReader(await res.Content.ReadAsStreamAsync());
for (string? l; (l = await rdr.ReadLineAsync()) != null;) if (l.StartsWith("data:")) Console.WriteLine(l);