@synap-core/workspace-templates 0.11.0 → 0.23.0

package/capabilities/jev.capability.json

@@ -0,0 +1,226 @@
+{
+  "apiVersion": "synap/v1",
+  "kind": "capability",
+  "meta": {
+    "slug": "jev",
+    "name": "Jev (TypeSafe decision model)",
+    "description": "Ask Jev, TypeSafe's decision model, to pick one option, place something on an ordered scale, or answer yes/no, with calibrated probabilities. Several questions can go in one call. Read-only: nothing is saved unless you choose to. Bring your own TypeSafe API key (console.typesafe.ai).",
+    "tags": ["capability"],
+    "isPublic": true,
+    "syncByDefault": true
+  },
+  "spec": {
+    "key": "jev",
+    "name": "Jev Decision Model",
+    "description": "Jev decision model (TypeSafe System One): choose, score, yes/no, batched. Bring your own key.",
+    "params": [
+      {
+        "name": "jevApiKey",
+        "label": "TypeSafe API key",
+        "type": "text",
+        "required": true,
+        "description": "Your TypeSafe API key from console.typesafe.ai. Stored encrypted in the pod vault; never in the template."
+      }
+    ],
+    "vault": [
+      {
+        "ref": "jevApiKeySecret",
+        "name": "{{name}} Jev API key",
+        "value": "{{jevApiKey}}",
+        "type": "api_key",
+        "description": "Jev API key for the jev_api connector."
+      }
+    ],
+    "tools": [
+      {
+        "name": "jev_api",
+        "kind": "api",
+        "description": "Authenticated HTTP access to TypeSafe's API (https://api.typesafe.ai, POST /v1/systemone). The dispatcher injects the vaulted key as `Authorization: Bearer <key>`; credentialRef is remapped to vault://<id> at apply time.",
+        "credentialRef": "jevApiKeySecret",
+        "executor": "is-agent",
+        "config": {
+          "baseUrl": "https://api.typesafe.ai",
+          "auth": {
+            "in": "header",
+            "name": "Authorization",
+            "prefix": "Bearer "
+          }
+        }
+      }
+    ],
+    "skills": [
+      {
+        "intent": "run_external_job",
+        "kind": "code",
+        "scope": "pod",
+        "requires": ["jev_api"],
+        "executionMode": "sync",
+        "timeoutSeconds": 60,
+        "metadata": {
+          "readOnly": true,
+          "verbType": "read"
+        },
+        "name": "jev_choose",
+        "description": "Ask Jev to pick ONE option about some content, with a probability per option and Jev's confidence. Read-only: saves nothing. Args: { state: string|object (the content), question: string, options: string[] (2+ keys Jev answers with), descriptions?: { key: what it means }, minConfidence?: number 0-1 }. Optional model: a Jev model name or alias (default jev-latest). Returns { choice, confidence, confident, probabilities, model, usage }. Confidence is advice, never permission to act.",
+        "code": "// Jev (TypeSafe System One). One call: POST /v1/systemone { model, state, questions }.\n// callProvider resolves the jev_api tool by NAME and injects the vaulted key as a Bearer header.\n// The model is a call argument, never an install-time value baked into this code: skill code\n// that carries install params can never be re-applied by the pod's capability reconcile.\nconst MODEL = typeof args?.model === 'string' && args.model.trim() ? args.model.trim() : 'jev-latest';\nasync function systemOne(fn, state, questions) {\n  const res = await callProvider('jev_api', 'POST', '/v1/systemone', { model: MODEL, state, questions });\n  if (typeof res?.status === 'number' && (res.status < 200 || res.status >= 300)) {\n    throw new Error(fn + ': Jev answered ' + res.status + ' ' + JSON.stringify(res?.body ?? '').slice(0, 300));\n  }\n  const out = res?.body ?? res;\n  if (!out || typeof out.answers !== 'object') throw new Error(fn + ': Jev returned no answers');\n  return out;\n}\nfunction stateOf(fn, args) {\n  const st = args?.state;\n  if (typeof st === 'string' ? !st.trim() : (st == null || typeof st !== 'object')) {\n    throw new Error(fn + ': state is required (the content the question is about: text or JSON)');\n  }\n  return st;\n}\n\nconst fn = 'jev_choose';\nconst state = stateOf(fn, args);\nconst question = String(args?.question ?? '').trim();\nif (!question) throw new Error(fn + ': question is required');\n// options: the keys Jev answers with; descriptions (optional): what each key means.\nif (!Array.isArray(args?.options)) throw new Error(fn + ': options must be a list of option keys');\nconst keys = args.options.map((o) => String(o ?? '').trim()).filter(Boolean);\nif (keys.length < 2) throw new Error(fn + ': give at least 2 options');\nconst descriptions = args?.descriptions && typeof args.descriptions === 'object' && !Array.isArray(args.descriptions) ? args.descriptions : {};\nconst criteria = Object.fromEntries(keys.map((k) => [k, typeof descriptions[k] === 'string' && descriptions[k].trim() ? descriptions[k].trim() : k]));\nconst out = await systemOne(fn, state, { decision: { type: 'choice', instructions: question, criteria } });\nconst a = out.answers.decision ?? {};\nconst min = Number(args?.minConfidence);\nconst confidence = typeof a.confidence === 'number' ? a.confidence : null;\nconst confident = Number.isFinite(min) ? (confidence ?? 0) >= min : null;\nreturn { choice: a.choice ?? null, confidence, confident, probabilities: a.probabilities ?? {}, model: out.model ?? null, usage: out.usage ?? null };\n",
+        "parameters": {
+          "state": "string",
+          "question": "string",
+          "options": "array",
+          "descriptions": "object?",
+          "minConfidence": "number?",
+          "model": "string?"
+        }
+      },
+      {
+        "intent": "run_external_job",
+        "kind": "code",
+        "scope": "pod",
+        "requires": ["jev_api"],
+        "executionMode": "sync",
+        "timeoutSeconds": 60,
+        "metadata": {
+          "readOnly": true,
+          "verbType": "read"
+        },
+        "name": "jev_score",
+        "description": "Ask Jev to place content on an ordered scale (lowest level first). Read-only. Args: { state, question: string, levels: string[] (2+, ordered) }. Optional model: a Jev model name or alias (default jev-latest). Returns { score (may fall between levels), confidence, legend, probabilities, model, usage }.",
+        "code": "// Jev (TypeSafe System One). One call: POST /v1/systemone { model, state, questions }.\n// callProvider resolves the jev_api tool by NAME and injects the vaulted key as a Bearer header.\n// The model is a call argument, never an install-time value baked into this code: skill code\n// that carries install params can never be re-applied by the pod's capability reconcile.\nconst MODEL = typeof args?.model === 'string' && args.model.trim() ? args.model.trim() : 'jev-latest';\nasync function systemOne(fn, state, questions) {\n  const res = await callProvider('jev_api', 'POST', '/v1/systemone', { model: MODEL, state, questions });\n  if (typeof res?.status === 'number' && (res.status < 200 || res.status >= 300)) {\n    throw new Error(fn + ': Jev answered ' + res.status + ' ' + JSON.stringify(res?.body ?? '').slice(0, 300));\n  }\n  const out = res?.body ?? res;\n  if (!out || typeof out.answers !== 'object') throw new Error(fn + ': Jev returned no answers');\n  return out;\n}\nfunction stateOf(fn, args) {\n  const st = args?.state;\n  if (typeof st === 'string' ? !st.trim() : (st == null || typeof st !== 'object')) {\n    throw new Error(fn + ': state is required (the content the question is about: text or JSON)');\n  }\n  return st;\n}\n\nconst fn = 'jev_score';\nconst state = stateOf(fn, args);\nconst question = String(args?.question ?? '').trim();\nif (!question) throw new Error(fn + ': question is required');\nconst levels = Array.isArray(args?.levels) ? args.levels.map((l) => String(l).trim()).filter(Boolean) : [];\nif (levels.length < 2) throw new Error(fn + ': levels must list at least 2 ordered levels, lowest first');\nconst out = await systemOne(fn, state, { rating: { type: 'score', instructions: question, criteria: levels } });\nconst a = out.answers.rating ?? {};\nreturn { score: a.score ?? null, confidence: a.confidence ?? null, legend: a.legend ?? null, probabilities: a.probabilities ?? {}, model: out.model ?? null, usage: out.usage ?? null };\n",
+        "parameters": {
+          "state": "string",
+          "question": "string",
+          "levels": "array",
+          "model": "string?"
+        }
+      },
+      {
+        "intent": "run_external_job",
+        "kind": "code",
+        "scope": "pod",
+        "requires": ["jev_api"],
+        "executionMode": "sync",
+        "timeoutSeconds": 60,
+        "metadata": {
+          "readOnly": true,
+          "verbType": "read"
+        },
+        "name": "jev_noul",
+        "description": "Ask Jev a yes/no question about content; returns the probability of yes (no confidence field). Read-only. Args: { state, question: string }. Optional model: a Jev model name or alias (default jev-latest). Returns { probabilityYes, model, usage }.",
+        "code": "// Jev (TypeSafe System One). One call: POST /v1/systemone { model, state, questions }.\n// callProvider resolves the jev_api tool by NAME and injects the vaulted key as a Bearer header.\n// The model is a call argument, never an install-time value baked into this code: skill code\n// that carries install params can never be re-applied by the pod's capability reconcile.\nconst MODEL = typeof args?.model === 'string' && args.model.trim() ? args.model.trim() : 'jev-latest';\nasync function systemOne(fn, state, questions) {\n  const res = await callProvider('jev_api', 'POST', '/v1/systemone', { model: MODEL, state, questions });\n  if (typeof res?.status === 'number' && (res.status < 200 || res.status >= 300)) {\n    throw new Error(fn + ': Jev answered ' + res.status + ' ' + JSON.stringify(res?.body ?? '').slice(0, 300));\n  }\n  const out = res?.body ?? res;\n  if (!out || typeof out.answers !== 'object') throw new Error(fn + ': Jev returned no answers');\n  return out;\n}\nfunction stateOf(fn, args) {\n  const st = args?.state;\n  if (typeof st === 'string' ? !st.trim() : (st == null || typeof st !== 'object')) {\n    throw new Error(fn + ': state is required (the content the question is about: text or JSON)');\n  }\n  return st;\n}\n\nconst fn = 'jev_noul';\nconst state = stateOf(fn, args);\nconst question = String(args?.question ?? '').trim();\nif (!question) throw new Error(fn + ': question is required (a yes/no question)');\nconst out = await systemOne(fn, state, { answer: { type: 'noul', instructions: question } });\nconst a = out.answers.answer ?? {};\nreturn { probabilityYes: typeof a.noul === 'number' ? a.noul : null, model: out.model ?? null, usage: out.usage ?? null };\n",
+        "parameters": {
+          "state": "string",
+          "question": "string",
+          "model": "string?"
+        }
+      },
+      {
+        "intent": "run_external_job",
+        "kind": "code",
+        "scope": "pod",
+        "requires": ["jev_api"],
+        "executionMode": "sync",
+        "timeoutSeconds": 60,
+        "metadata": {
+          "readOnly": true,
+          "verbType": "read"
+        },
+        "name": "jev_ask",
+        "description": "Ask Jev several questions about the same content in ONE call (cheaper and faster than one call each). Read-only. Args: { state, questions: { name: { type: 'choice'|'score'|'noul', instructions, criteria? } } }. Optional model: a Jev model name or alias (default jev-latest). Returns { answers (keyed by your names), model, usage }.",
+        "code": "// Jev (TypeSafe System One). One call: POST /v1/systemone { model, state, questions }.\n// callProvider resolves the jev_api tool by NAME and injects the vaulted key as a Bearer header.\n// The model is a call argument, never an install-time value baked into this code: skill code\n// that carries install params can never be re-applied by the pod's capability reconcile.\nconst MODEL = typeof args?.model === 'string' && args.model.trim() ? args.model.trim() : 'jev-latest';\nasync function systemOne(fn, state, questions) {\n  const res = await callProvider('jev_api', 'POST', '/v1/systemone', { model: MODEL, state, questions });\n  if (typeof res?.status === 'number' && (res.status < 200 || res.status >= 300)) {\n    throw new Error(fn + ': Jev answered ' + res.status + ' ' + JSON.stringify(res?.body ?? '').slice(0, 300));\n  }\n  const out = res?.body ?? res;\n  if (!out || typeof out.answers !== 'object') throw new Error(fn + ': Jev returned no answers');\n  return out;\n}\nfunction stateOf(fn, args) {\n  const st = args?.state;\n  if (typeof st === 'string' ? !st.trim() : (st == null || typeof st !== 'object')) {\n    throw new Error(fn + ': state is required (the content the question is about: text or JSON)');\n  }\n  return st;\n}\n\nconst fn = 'jev_ask';\nconst state = stateOf(fn, args);\nconst questions = args?.questions;\nif (!questions || typeof questions !== 'object' || Array.isArray(questions) || Object.keys(questions).length === 0) {\n  throw new Error(fn + ': questions must be a non-empty { name: { type: choice|score|noul, instructions, criteria? } } map');\n}\nfor (const [name, q] of Object.entries(questions)) {\n  if (!['choice', 'score', 'noul'].includes(q?.type)) throw new Error(fn + ': question ' + name + ' has type ' + q?.type + '; use choice, score or noul');\n}\nconst out = await systemOne(fn, state, questions);\nreturn { answers: out.answers, model: out.model ?? null, usage: out.usage ?? null };\n",
+        "parameters": {
+          "state": "string",
+          "questions": "object",
+          "model": "string?"
+        }
+      },
+      {
+        "name": "jev-routing-policy",
+        "kind": "instruction",
+        "scope": "pod",
+        "description": "When to route a decision through Jev, which verb to use, and what to do with a low-confidence answer. Pure know-how.",
+        "code": "# Routing a decision through Jev\n\nJev answers typed questions about content you give it (`state`): pick one option (jev_choose), place on an ordered scale (jev_score), yes/no probability (jev_noul), or several at once (jev_ask, one call). It does not write text or look facts up.\n\nBefore you call it, read the person's own policy if they wrote one (a document named \"Jev policy\"): which decisions go to Jev, the minimum confidence, the default options. It wins over this text.\n\nAlways include an abstain option (\"none_of_these\") in a choice. A confidence under the person's minimum is not a decision: say so and ask the person. A Jev answer is advice; any commitment it leads to still goes through the person."
+      }
+    ],
+    "provides": ["run_external_job"],
+    "playbooks": [
+      {
+        "name": "Decide with Jev",
+        "description": "Frame a decision, ask Jev to choose or score, and record the decision once a person confirms it.",
+        "goalTemplate": "Decide: {question}. Options: {options}. Ordered levels instead of options (optional): {levels}. Minimum confidence: {minConfidence}.\n\n1. Restate the question and the options; add 'none_of_these' and the status quo if missing.\n2. If levels are given, call jev_score; otherwise call jev_choose with minConfidence.\n3. Below the minimum confidence, stop and ask the person to choose.\n4. Otherwise propose a decision entity with the choice, Jev's probabilities as rationale, and the other options as alternatives. A person confirms it.",
+        "params": [
+          {
+            "name": "question",
+            "label": "Question",
+            "type": "text",
+            "required": true
+          },
+          {
+            "name": "options",
+            "label": "Options (one per line)",
+            "type": "text",
+            "required": true
+          },
+          {
+            "name": "levels",
+            "label": "Ordered levels, lowest first (optional)",
+            "type": "text",
+            "required": false
+          },
+          {
+            "name": "minConfidence",
+            "label": "Minimum confidence (0-1)",
+            "type": "text",
+            "required": false,
+            "default": "0.6"
+          }
+        ],
+        "channelSpec": {
+          "type": "THREAD",
+          "aiReactionMode": "only_mentioned"
+        },
+        "executor": "is-agent",
+        "status": "active",
+        "stages": [
+          {
+            "key": "frame",
+            "name": "Frame",
+            "category": "started",
+            "goal": "Question and options are explicit and mutually exclusive.",
+            "grants": [
+              {
+                "kind": "skill",
+                "id": "jev-routing-policy"
+              }
+            ]
+          },
+          {
+            "key": "ask-jev",
+            "name": "Ask Jev",
+            "category": "started",
+            "goal": "Jev's choice or scores with probabilities.",
+            "grants": [
+              {
+                "kind": "skill",
+                "id": "jev_choose"
+              },
+              {
+                "kind": "skill",
+                "id": "jev_score"
+              }
+            ]
+          },
+          {
+            "key": "record",
+            "name": "Record",
+            "category": "started",
+            "goal": "A decision entity proposed with rationale and alternatives.",
+            "gate": {
+              "kind": "human"
+            }
+          }
+        ]
+      }
+    ]
+  },
+  "dependencies": []
+}

package/capabilities/lead-conversion-enrollment.capability.json

@@ -0,0 +1,246 @@
+{
+  "apiVersion": "synap/v1",
+  "kind": "capability",
+  "meta": {
+    "slug": "lead-conversion-enrollment",
+    "name": "Lead Conversion Enrollment",
+    "description": "When a new lead is created, starts the conversion playbook that matches its lead source: Cold Outreach, Inbound, Referral or Standard. Install with the lead-conversion playbooks in the same CRM workspace, then adjust the mapping to your funnel.",
+    "tags": [
+      "capability"
+    ],
+    "isPublic": true,
+    "syncByDefault": true
+  },
+  "spec": {
+    "key": "lead-conversion-enrollment",
+    "name": "Lead Conversion Enrollment",
+    "description": "The source → playbook router. When a new lead (person) is created, this automation reads the lead's `leadSource` and starts the matching conversion-journey session on it: cold-outreach/linkedin → Cold Outreach, landing-page/inbound-call → Inbound, referral → Referral, everything else → Standard. Pairs with the `lead-conversion` LoopDefinition seed (synap-backend/templates/loops/lead-conversion.loop.json), which materializes those four playbooks — install BOTH into the same CRM workspace so the playbook_run nodes resolve by name. Enrollment is idempotent per lead (runPlaybook idempotentBySubject), so re-firing never double-enrolls. STARTER — edit the source→playbook mapping and the trigger filter to match your funnel.",
+    "params": [],
+    "vault": [],
+    "tools": [],
+    "skills": [],
+    "provides": [],
+    "playbooks": [],
+    "automations": [
+      {
+        "name": "Lead Conversion Enrollment",
+        "description": "On new person: read the lead, switch on its `leadSource`, and start the matching conversion playbook on the lead (idempotent per lead). Seeded ACTIVE so it fires on real lead creation. A person created without a recognized lead source matches no case and is simply not auto-enrolled — a natural gate. Requires the `lead-conversion` playbooks (Cold Outreach / Inbound / Referral / Standard) to exist in this workspace.",
+        "triggerType": "event",
+        "triggerConfig": {
+          "eventPattern": "entity.create.completed",
+          "filters": {
+            "profileSlug": "person"
+          }
+        },
+        "status": "active",
+        "metadata": {
+          "kind": "lead-conversion-enrollment",
+          "pairsWith": "lead-conversion"
+        },
+        "flowDefinition": {
+          "nodes": [
+            {
+              "id": "trigger",
+              "type": "trigger",
+              "position": {
+                "x": 0,
+                "y": 0
+              },
+              "data": {
+                "triggerType": "event",
+                "label": "New person created",
+                "config": {
+                  "eventPattern": "entity.create.completed",
+                  "filters": {
+                    "profileSlug": "person"
+                  }
+                }
+              }
+            },
+            {
+              "id": "read-lead",
+              "type": "entity_read",
+              "position": {
+                "x": 0,
+                "y": 120
+              },
+              "data": {
+                "label": "Load the new lead",
+                "entityId": "{{trigger.payload.subjectId}}",
+                "_note": "The entity.create.completed event data payload is only { profileSlug, title } — it does NOT carry the entity's properties. So the lead's `leadSource` must be READ from the entity here; the switch below matches on this node's output, not on the trigger payload."
+              }
+            },
+            {
+              "id": "route-by-source",
+              "type": "switch",
+              "position": {
+                "x": 0,
+                "y": 240
+              },
+              "data": {
+                "label": "Route by lead source",
+                "expression": "{{steps.read-lead.output.entity.properties.leadSource}}",
+                "cases": [
+                  {
+                    "value": "cold-outreach",
+                    "label": "Cold outreach"
+                  },
+                  {
+                    "value": "linkedin",
+                    "label": "LinkedIn"
+                  },
+                  {
+                    "value": "landing-page",
+                    "label": "Landing page"
+                  },
+                  {
+                    "value": "inbound-call",
+                    "label": "Inbound call"
+                  },
+                  {
+                    "value": "referral",
+                    "label": "Referral"
+                  },
+                  {
+                    "value": "twitter",
+                    "label": "Twitter / X"
+                  },
+                  {
+                    "value": "event",
+                    "label": "Event"
+                  },
+                  {
+                    "value": "other",
+                    "label": "Other"
+                  }
+                ],
+                "_note": "The switch has NO default handle: a value that matches no case prunes all outgoing edges (no enrollment). So EVERY leadSource enum value is enumerated as a case; the ones without a tailored overlay (twitter, event, other) route to the Standard playbook. Keep these `value`s in lock-step with the person.leadSource enumValues in crm.yaml."
+              }
+            },
+            {
+              "id": "run-cold-outreach",
+              "type": "playbook_run",
+              "position": {
+                "x": -300,
+                "y": 360
+              },
+              "data": {
+                "label": "Enroll → Cold Outreach",
+                "playbookName": "Conversion — Cold Outreach",
+                "paramsMapping": {
+                  "subjectId": "{{trigger.payload.subjectId}}"
+                }
+              }
+            },
+            {
+              "id": "run-inbound",
+              "type": "playbook_run",
+              "position": {
+                "x": -100,
+                "y": 360
+              },
+              "data": {
+                "label": "Enroll → Inbound",
+                "playbookName": "Conversion — Inbound",
+                "paramsMapping": {
+                  "subjectId": "{{trigger.payload.subjectId}}"
+                }
+              }
+            },
+            {
+              "id": "run-referral",
+              "type": "playbook_run",
+              "position": {
+                "x": 100,
+                "y": 360
+              },
+              "data": {
+                "label": "Enroll → Referral",
+                "playbookName": "Conversion — Referral",
+                "paramsMapping": {
+                  "subjectId": "{{trigger.payload.subjectId}}"
+                }
+              }
+            },
+            {
+              "id": "run-standard",
+              "type": "playbook_run",
+              "position": {
+                "x": 300,
+                "y": 360
+              },
+              "data": {
+                "label": "Enroll → Standard (fallback)",
+                "playbookName": "Conversion — Standard",
+                "paramsMapping": {
+                  "subjectId": "{{trigger.payload.subjectId}}"
+                }
+              }
+            }
+          ],
+          "edges": [
+            {
+              "id": "e-trigger",
+              "source": "trigger",
+              "target": "read-lead"
+            },
+            {
+              "id": "e-read",
+              "source": "read-lead",
+              "target": "route-by-source"
+            },
+            {
+              "id": "e-cold",
+              "source": "route-by-source",
+              "target": "run-cold-outreach",
+              "sourceHandle": "cold-outreach"
+            },
+            {
+              "id": "e-linkedin",
+              "source": "route-by-source",
+              "target": "run-cold-outreach",
+              "sourceHandle": "linkedin"
+            },
+            {
+              "id": "e-landing",
+              "source": "route-by-source",
+              "target": "run-inbound",
+              "sourceHandle": "landing-page"
+            },
+            {
+              "id": "e-call",
+              "source": "route-by-source",
+              "target": "run-inbound",
+              "sourceHandle": "inbound-call"
+            },
+            {
+              "id": "e-referral",
+              "source": "route-by-source",
+              "target": "run-referral",
+              "sourceHandle": "referral"
+            },
+            {
+              "id": "e-twitter",
+              "source": "route-by-source",
+              "target": "run-standard",
+              "sourceHandle": "twitter"
+            },
+            {
+              "id": "e-event",
+              "source": "route-by-source",
+              "target": "run-standard",
+              "sourceHandle": "event"
+            },
+            {
+              "id": "e-other",
+              "source": "route-by-source",
+              "target": "run-standard",
+              "sourceHandle": "other"
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "dependencies": []
+}