agentic-relay 4.1.2 → 4.2.0

package/bin/lib/api.mjs

@@ -113,13 +113,12 @@ export function sessionEnd({ sessionId }, { apiKey, timeoutMs }) {
  * Returns the structured SettleResult ({ ok, error_code, ... }); does not throw on a
  * 402 policy/charge rejection — the caller inspects `ok`.
  */
-export async function sessionPay({ sessionId, referenceId, paymentCredential }, { apiKey, timeoutMs }) {
+export async function sessionPay({ sessionId, paymentCredential }, { apiKey, timeoutMs }) {
   try {
     return await apiPost(
       "/session/pay",
       {
         ...(sessionId ? { session_id: sessionId } : {}),
-        ...(referenceId ? { reference_id: referenceId } : {}),
         ...(paymentCredential ? { payment_credential: paymentCredential } : {}),
       },
       { apiKey, timeoutMs },

package/bin/lib/commands.mjs

@@ -37,6 +37,22 @@ function normalizeCapability(c) {
     ad_unit_id: c.ad_unit_id || null,
     description: c.description || "",
     click_url: c.click_url || null,
+    // Track-record evidence card (server-side from capability_profile.fit). The
+    // backend already ranks/trims and strips confidence; pass these through as-is
+    // so --json carries the exact same shape the API and MCP return. Empty arrays
+    // when a capability has no roller profile yet.
+    summary: c.summary || "",
+    feedback_payout:
+      typeof c.feedback_payout === "number"
+        ? c.feedback_payout
+        : typeof c.clearing_price_cents === "number"
+          ? c.clearing_price_cents
+          : 0,
+    offers_paid_deliverable: Boolean(c.offers_paid_deliverable),
+    deliverable: c.deliverable || null,
+    proven_for: Array.isArray(c.proven_for) ? c.proven_for : [],
+    watch_out: Array.isArray(c.watch_out) ? c.watch_out : [],
+    works_with: Array.isArray(c.works_with) ? c.works_with : [],
   };
 }
 

package/bin/lib/parse.mjs

@@ -4,7 +4,7 @@
  * The capability-session agent returns markdown + code blocks inside the
  * `message` string. Those payloads sometimes contain lone backslashes or raw
  * control characters that make strict `JSON.parse` throw (spec §2). Never let a
- * parse error crash a batch — degrade gracefully instead.
+ * parse error crash a session turn — degrade gracefully instead.
  *
  * Strategy (in order):
  *   1. plain JSON.parse

package/bin/relay-core.mjs

@@ -147,6 +147,19 @@ const fmtSearch = (e) => {
     const desc = c.description.length > 90 ? c.description.slice(0, 90) + "…" : c.description;
     lines.push(`  ${kind} ${c.slug}  (rel ${rel}, ${price})  ${c.name}`);
     if (desc) lines.push(`        ${desc}`);
+    // Track-record evidence card (when the capability has a roller profile). --json
+    // carries the full structured fields; this is the scannable human digest.
+    if (Array.isArray(c.proven_for) && c.proven_for.length) {
+      lines.push(`        proven: ${c.proven_for.map((p) => p.use_case).join("; ")}`);
+    }
+    if (Array.isArray(c.watch_out) && c.watch_out.length) {
+      lines.push(`        watch:  ${c.watch_out.map((w) => w.use_case).join("; ")}`);
+    }
+    if (Array.isArray(c.works_with) && c.works_with.length) {
+      const flag = (r) => (r === "conflicts" || r === "requires" ? `${r}!` : r);
+      lines.push(`        works-with: ${c.works_with.map((w) => `${w.companion_tool} (${flag(w.relationship)})`).join(", ")}`);
+    }
+    if (c.offers_paid_deliverable) lines.push(`        offers paid deliverable`);
   }
   // Surface the spend policy in human output too — agents reading --json get
   // the full payment_context object; humans shouldn't be blind to it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-relay",
-  "version": "4.1.2",
+  "version": "4.2.0",
   "description": "Install Agent Relay AI search across 17+ agents — Claude Code, Codex, Cursor, Gemini CLI, Goose, Windsurf, Cline, BoltAI, Claude Desktop, VS Code, Amazon Q, Roo Code, Witsy, LibreChat, OpenClaw, Tome, Raycast — plus the `agentrelay` CLI for live agent sessions, payments, and deliverable fetch",
   "bin": {
     "agentrelay": "bin/cli.mjs"

package/skill/SKILL.md

@@ -57,6 +57,8 @@ This loop keeps raw transcripts out of your main context (only compact summaries
 
 When a search is part of a build, triage silently and proceed into sessions. When the user just asked what's available ("what's X", "find me a tool for Y", "ways to do Z"), the search results are the answer — don't dissolve them into generic advice. Respond with: a one-line framing, the relevant agents (name + what each does + price if paid), and a clear CTA — "Want me to start a session with <agent> to get exact integration steps?" Then act on their answer. If one result is the obvious match, offer to start that session directly rather than listing alternatives the user didn't ask to compare.
 
+**Read the evidence card when triaging.** Beyond `name`/`description`/`relevance`, each result may carry a track-record card built from real prior builds (present only once a capability has accumulated enough usage — many results won't have it yet, which is expected): `summary` (a fuller one-paragraph description), `proven_for[]` (`{use_case, note}` — what it keeps working for), `watch_out[]` (`{use_case, failure_mode}` — where it keeps failing), `works_with[]` (`{companion_tool, relationship, note}` where relationship ∈ `conflicts`/`redundant_with`/`requires`/`pairs_well`), plus `feedback_payout` (cents earned for qualifying feedback) and `offers_paid_deliverable`. Use these to pick the right tool and to sequence your stack: `requires`/`conflicts` entries are integration gotchas to act on, and `watch_out` tells you what to avoid asking it for. The card is ranked by the marketplace's internal confidence but that score is **not** exposed — treat the ordering as the signal. These are evidence to weigh against *your* local context (stack, constraints) — you make the call, the card doesn't make it for you.
+
 4. **Map each chosen agent in its own `session`.** How you parallelize depends on your host (see below). Each session follows the brief below, banks one spec, and ends. Scaffold the project while the mapping happens.
 
 **Parallelizing the mapping:**