@tangle-network/starter-foundry 0.7.3 → 0.13.2

package/registry/layers/agent-channels/slack/files/channels/slack.ts

@@ -0,0 +1,119 @@
+// MIT — adapted from nanoclaw (https://github.com/qwibitai/nanoclaw)
+//
+// Slack channel adapter. Verifies the v0 signing-secret HMAC on every
+// inbound Events API POST, parses event_callback for human "message"
+// events (skipping bot/edit/subtype noise), and sends replies via
+// chat.postMessage with bearer auth.
+//
+// Setup:
+//  1. https://api.slack.com/apps → Create New App.
+//  2. OAuth & Permissions → bot scopes: chat:write, channels:history,
+//     im:history, app_mentions:read. Install to workspace → SLACK_BOT_TOKEN
+//     (xoxb-...).
+//  3. Basic Information → Signing Secret → SLACK_SIGNING_SECRET.
+//  4. Event Subscriptions → Request URL: <your-https-url>/channels/slack.
+//     Subscribe to message.channels and/or app_mention.
+
+import { createHmac, timingSafeEqual } from 'node:crypto'
+
+const API = 'https://slack.com/api'
+const SIG_HEADER = 'x-slack-signature'
+const TS_HEADER = 'x-slack-request-timestamp'
+const REPLAY_WINDOW_SEC = 60 * 5
+
+export interface SlackInbound {
+  chatId: string
+  text: string
+  sender: string
+}
+
+interface SlackEventEnvelope {
+  type: 'url_verification' | 'event_callback'
+  challenge?: string
+  event?: SlackEvent
+}
+
+interface SlackEvent {
+  type: string
+  subtype?: string
+  channel: string
+  user?: string
+  bot_id?: string
+  text?: string
+  ts: string
+}
+
+function botToken(): string {
+  const t = process.env.SLACK_BOT_TOKEN
+  if (!t) throw new Error('SLACK_BOT_TOKEN not set')
+  return t
+}
+
+function signingSecret(): string {
+  const s = process.env.SLACK_SIGNING_SECRET
+  if (!s) throw new Error('SLACK_SIGNING_SECRET not set')
+  return s
+}
+
+/** v0 signing-secret verification per
+ *  https://api.slack.com/authentication/verifying-requests-from-slack —
+ *  HMAC-SHA256 over `v0:${ts}:${rawBody}`, compared with the v0= header. */
+function verifySignature(rawBody: string, sigHeader: string, ts: string, secret: string): boolean {
+  const tsNum = Number(ts)
+  if (!Number.isFinite(tsNum)) return false
+  if (Math.abs(Date.now() / 1000 - tsNum) > REPLAY_WINDOW_SEC) return false
+  const expected = `v0=${createHmac('sha256', secret).update(`v0:${ts}:${rawBody}`).digest('hex')}`
+  const a = Buffer.from(sigHeader)
+  const b = Buffer.from(expected)
+  if (a.length !== b.length) return false
+  return timingSafeEqual(a, b)
+}
+
+/** Parse a Slack Events API POST. Returns null for url_verification (caller
+ *  must echo `challenge` back as plain text), bot-authored messages, edit
+ *  subtypes, and non-message events. */
+export async function receive(req: Request): Promise<SlackInbound | null> {
+  const sig = req.headers.get(SIG_HEADER)
+  const ts = req.headers.get(TS_HEADER)
+  const raw = await req.text()
+  if (!sig || !ts || !verifySignature(raw, sig, ts, signingSecret())) {
+    throw new Error('slack: signature verification failed')
+  }
+  const env = JSON.parse(raw) as SlackEventEnvelope & { challenge?: string }
+  if (env.type === 'url_verification') return null
+  const ev = env.event
+  if (!ev) return null
+  if (ev.type !== 'message' && ev.type !== 'app_mention') return null
+  if (ev.subtype) return null // skip message_changed, message_deleted, etc.
+  if (ev.bot_id) return null // skip bot loops
+  if (!ev.text || !ev.user) return null
+  return { chatId: ev.channel, text: ev.text, sender: ev.user }
+}
+
+/** Send a message to a Slack channel/DM. Slack returns 200 even for logical
+ *  failures (auth, channel-not-found) — check `ok` in the response body and
+ *  surface `error` so the agent can react. */
+export async function send(chatId: string, text: string): Promise<void> {
+  const res = await fetch(`${API}/chat.postMessage`, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${botToken()}`,
+      'content-type': 'application/json; charset=utf-8',
+    },
+    body: JSON.stringify({ channel: chatId, text }),
+  })
+  if (!res.ok) {
+    throw new Error(`slack chat.postMessage ${res.status}`)
+  }
+  const body = (await res.json()) as { ok: boolean; error?: string }
+  if (!body.ok) {
+    throw new Error(`slack chat.postMessage error: ${body.error ?? 'unknown'}`)
+  }
+}
+
+export const channelMeta = {
+  id: 'slack' as const,
+  envVars: ['SLACK_BOT_TOKEN', 'SLACK_SIGNING_SECRET'] as const,
+  inbound: 'webhook' as const,
+  outbound: 'POST' as const,
+}

package/registry/layers/agent-channels/slack/manifest.json

@@ -0,0 +1,95 @@
+{
+  "id": "slack",
+  "slot": "agent-channels",
+  "description": "Slack channel adapter \u2014 Events API webhook (HMAC-verified) + chat.postMessage send. Composes with any agent-runtime bundle. Set SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET at deploy. Verifies the v0 signature scheme per Slack's signing-secret spec; rejects requests outside the 5-minute replay window.",
+  "appliesTo": [
+    "agent-runtime-account-executive-ts",
+    "agent-runtime-architect-ts",
+    "agent-runtime-auditor-ts",
+    "agent-runtime-biology-research-ts",
+    "agent-runtime-business-partner-ts",
+    "agent-runtime-career-coach-ts",
+    "agent-runtime-chef-ts",
+    "agent-runtime-chemistry-research-ts",
+    "agent-runtime-cmo-advisor-ts",
+    "agent-runtime-college-counselor-ts",
+    "agent-runtime-cs-research-ts",
+    "agent-runtime-cs-tutor-ts",
+    "agent-runtime-customer-success-ts",
+    "agent-runtime-data-analyst-ts",
+    "agent-runtime-designer-ts",
+    "agent-runtime-devops-ts",
+    "agent-runtime-doctor-ts",
+    "agent-runtime-engineering-manager-ts",
+    "agent-runtime-essay-coach-ts",
+    "agent-runtime-financial-analyst-ts",
+    "agent-runtime-fitness-coach-ts",
+    "agent-runtime-friend-ts",
+    "agent-runtime-game-designer-ts",
+    "agent-runtime-grant-writer-ts",
+    "agent-runtime-history-tutor-ts",
+    "agent-runtime-illustrator-ts",
+    "agent-runtime-language-tutor-ts",
+    "agent-runtime-legal-counsel-ts",
+    "agent-runtime-math-research-ts",
+    "agent-runtime-math-tutor-ts",
+    "agent-runtime-mediator-ts",
+    "agent-runtime-meditation-coach-ts",
+    "agent-runtime-ml-research-ts",
+    "agent-runtime-music-producer-ts",
+    "agent-runtime-novelist-coach-ts",
+    "agent-runtime-nutritionist-ts",
+    "agent-runtime-pentester-ts",
+    "agent-runtime-pharmacist-ts",
+    "agent-runtime-photographer-ts",
+    "agent-runtime-physics-research-ts",
+    "agent-runtime-product-manager-ts",
+    "agent-runtime-real-estate-ts",
+    "agent-runtime-recruiter-ts",
+    "agent-runtime-relationship-coach-ts",
+    "agent-runtime-research",
+    "agent-runtime-sales-engineer-ts",
+    "agent-runtime-screenwriter-ts",
+    "agent-runtime-security-engineer-ts",
+    "agent-runtime-tax-ts",
+    "agent-runtime-therapist-ts",
+    "agent-runtime-travel-planner-ts",
+    "agent-runtime-veterinarian-ts",
+    "agent-runtime-wealth-manager-ts",
+    "multi-agent-creative-studio-ts",
+    "multi-agent-legal-ops-ts",
+    "multi-agent-product-ops-ts",
+    "multi-agent-research-lab-ts",
+    "multi-agent-startup-team-ts"
+  ],
+  "provides": [
+    "channel:slack"
+  ],
+  "requires": [
+    "secure:webhook-in"
+  ],
+  "defaults": {
+    "channelSlackAvailable": true
+  },
+  "files": [
+    {
+      "source": "files/channels/slack.ts",
+      "target": "channels/slack.ts"
+    },
+    {
+      "source": "files/channels/slack.env.example",
+      "target": "channels/slack.env.example"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "channels/slack.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "channels/slack.ts"
+    ]
+  }
+}

package/registry/layers/agent-channels/telegram/files/channels/telegram.env.example

@@ -0,0 +1,9 @@
+# Telegram channel adapter
+# TELEGRAM_BOT_TOKEN: open Telegram, message @BotFather, run /newbot, follow
+#   the prompts. BotFather replies with a token like "1234567890:AAH...". Paste
+#   it here. Treat as a secret — anyone with the token can impersonate the bot.
+TELEGRAM_BOT_TOKEN=
+
+# After deploy, register your webhook (one-time, replace <URL>):
+#   curl -X POST "https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/setWebhook" \
+#        -d "url=<URL>/channels/telegram"

package/registry/layers/agent-channels/telegram/files/channels/telegram.ts

@@ -0,0 +1,72 @@
+// MIT — adapted from nanoclaw (https://github.com/qwibitai/nanoclaw)
+//
+// Telegram channel adapter. Receives Bot API webhook updates and sends
+// replies via sendMessage. The in-sandbox agent's HTTP server invokes
+// receive() per webhook POST and send() to push a reply.
+//
+// Setup:
+//  1. Talk to @BotFather, run /newbot, paste the token into TELEGRAM_BOT_TOKEN.
+//  2. POST https://api.telegram.org/bot<TOKEN>/setWebhook with url=<your-https-url>.
+//  3. Telegram POSTs JSON updates to that URL — pipe them into receive().
+
+const API = 'https://api.telegram.org'
+
+export interface TelegramInbound {
+  chatId: string
+  text: string
+  sender: string
+}
+
+export interface TelegramUpdate {
+  update_id: number
+  message?: TelegramMessage
+  edited_message?: TelegramMessage
+  channel_post?: TelegramMessage
+}
+
+interface TelegramMessage {
+  message_id: number
+  chat: { id: number; type: string }
+  text?: string
+  caption?: string
+  from?: { id: number; first_name?: string; username?: string }
+}
+
+function token(): string {
+  const t = process.env.TELEGRAM_BOT_TOKEN
+  if (!t) throw new Error('TELEGRAM_BOT_TOKEN not set')
+  return t
+}
+
+/** Parse a Telegram webhook POST. Returns null if it isn't a text message
+ *  we can act on (sticker, photo without caption, service event, etc.). */
+export async function receive(req: Request): Promise<TelegramInbound | null> {
+  const update = (await req.json()) as TelegramUpdate
+  const msg = update.message ?? update.edited_message ?? update.channel_post
+  if (!msg) return null
+  const text = msg.text ?? msg.caption
+  if (!text) return null
+  const sender = msg.from?.first_name ?? msg.from?.username ?? `chat:${msg.chat.id}`
+  return { chatId: String(msg.chat.id), text, sender }
+}
+
+/** Send a text reply. Throws on non-2xx so the agent's HTTP layer can
+ *  surface the failure (Telegram's error body has a useful description). */
+export async function send(chatId: string, text: string): Promise<void> {
+  const res = await fetch(`${API}/bot${token()}/sendMessage`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ chat_id: chatId, text }),
+  })
+  if (!res.ok) {
+    const body = await res.text().catch(() => '')
+    throw new Error(`telegram sendMessage ${res.status}: ${body.slice(0, 200)}`)
+  }
+}
+
+export const channelMeta = {
+  id: 'telegram' as const,
+  envVars: ['TELEGRAM_BOT_TOKEN'] as const,
+  inbound: 'webhook' as const,
+  outbound: 'POST' as const,
+}

package/registry/layers/agent-channels/telegram/manifest.json

@@ -0,0 +1,95 @@
+{
+  "id": "telegram",
+  "slot": "agent-channels",
+  "description": "Telegram bot adapter \u2014 webhook receive + send. Composes with any agent-runtime bundle. Set TELEGRAM_BOT_TOKEN at deploy. The in-sandbox agent registers a webhook with Telegram, receives updates via the agent's HTTP server, and sends replies via the Bot API.",
+  "appliesTo": [
+    "agent-runtime-account-executive-ts",
+    "agent-runtime-architect-ts",
+    "agent-runtime-auditor-ts",
+    "agent-runtime-biology-research-ts",
+    "agent-runtime-business-partner-ts",
+    "agent-runtime-career-coach-ts",
+    "agent-runtime-chef-ts",
+    "agent-runtime-chemistry-research-ts",
+    "agent-runtime-cmo-advisor-ts",
+    "agent-runtime-college-counselor-ts",
+    "agent-runtime-cs-research-ts",
+    "agent-runtime-cs-tutor-ts",
+    "agent-runtime-customer-success-ts",
+    "agent-runtime-data-analyst-ts",
+    "agent-runtime-designer-ts",
+    "agent-runtime-devops-ts",
+    "agent-runtime-doctor-ts",
+    "agent-runtime-engineering-manager-ts",
+    "agent-runtime-essay-coach-ts",
+    "agent-runtime-financial-analyst-ts",
+    "agent-runtime-fitness-coach-ts",
+    "agent-runtime-friend-ts",
+    "agent-runtime-game-designer-ts",
+    "agent-runtime-grant-writer-ts",
+    "agent-runtime-history-tutor-ts",
+    "agent-runtime-illustrator-ts",
+    "agent-runtime-language-tutor-ts",
+    "agent-runtime-legal-counsel-ts",
+    "agent-runtime-math-research-ts",
+    "agent-runtime-math-tutor-ts",
+    "agent-runtime-mediator-ts",
+    "agent-runtime-meditation-coach-ts",
+    "agent-runtime-ml-research-ts",
+    "agent-runtime-music-producer-ts",
+    "agent-runtime-novelist-coach-ts",
+    "agent-runtime-nutritionist-ts",
+    "agent-runtime-pentester-ts",
+    "agent-runtime-pharmacist-ts",
+    "agent-runtime-photographer-ts",
+    "agent-runtime-physics-research-ts",
+    "agent-runtime-product-manager-ts",
+    "agent-runtime-real-estate-ts",
+    "agent-runtime-recruiter-ts",
+    "agent-runtime-relationship-coach-ts",
+    "agent-runtime-research",
+    "agent-runtime-sales-engineer-ts",
+    "agent-runtime-screenwriter-ts",
+    "agent-runtime-security-engineer-ts",
+    "agent-runtime-tax-ts",
+    "agent-runtime-therapist-ts",
+    "agent-runtime-travel-planner-ts",
+    "agent-runtime-veterinarian-ts",
+    "agent-runtime-wealth-manager-ts",
+    "multi-agent-creative-studio-ts",
+    "multi-agent-legal-ops-ts",
+    "multi-agent-product-ops-ts",
+    "multi-agent-research-lab-ts",
+    "multi-agent-startup-team-ts"
+  ],
+  "provides": [
+    "channel:telegram"
+  ],
+  "requires": [
+    "secure:webhook-in"
+  ],
+  "defaults": {
+    "channelTelegramAvailable": true
+  },
+  "files": [
+    {
+      "source": "files/channels/telegram.ts",
+      "target": "channels/telegram.ts"
+    },
+    {
+      "source": "files/channels/telegram.env.example",
+      "target": "channels/telegram.env.example"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "channels/telegram.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "channels/telegram.ts"
+    ]
+  }
+}

package/registry/layers/agent-channels/whatsapp/files/channels/whatsapp.env.example

@@ -0,0 +1,31 @@
+# WhatsApp Cloud API — Meta's official Graph API path.
+# Set up: https://developers.facebook.com/docs/whatsapp/cloud-api/get-started
+#
+# Step-by-step:
+#  1. Create a Meta app:                  https://developers.facebook.com/apps/
+#  2. Add the "WhatsApp" product to it.
+#  3. Copy the access token + phone number ID from the WhatsApp dashboard.
+#  4. Copy the App Secret from App Settings → Basic.
+#  5. Pick any verify token (a string you choose) — Meta sends it back during
+#     the webhook handshake so you can confirm ownership.
+#  6. Configure the webhook URL in the WhatsApp dashboard:
+#       https://<your-host>/webhooks/whatsapp
+#     subscribed to the `messages` field.
+
+# Bearer token for graph.facebook.com calls.
+# Source: developers.facebook.com → Your App → WhatsApp → API Setup → Temporary access token
+# (Use a permanent System User token in production.)
+WHATSAPP_ACCESS_TOKEN=
+
+# Numeric phone number ID issued by Meta (NOT the phone number itself).
+# Source: same WhatsApp API Setup page.
+WHATSAPP_PHONE_NUMBER_ID=
+
+# App secret used to verify the X-Hub-Signature-256 header on inbound webhooks.
+# Source: developers.facebook.com → Your App → Settings → Basic → App Secret
+WHATSAPP_APP_SECRET=
+
+# Arbitrary string YOU choose. Meta echoes it back during the GET-challenge
+# handshake when subscribing the webhook; verifyWebhook() compares it
+# constant-time against this env var.
+WHATSAPP_VERIFY_TOKEN=

package/registry/layers/agent-channels/whatsapp/files/channels/whatsapp.ts

@@ -0,0 +1,158 @@
+// MIT — adapted from nanoclaw (https://github.com/qwibitai/nanoclaw)
+//
+// WhatsApp Cloud API channel adapter.
+// Meta's official path: graph.facebook.com/v18.0/<PHONE_NUMBER_ID>/messages.
+// We deliberately do NOT use Twilio; Meta's first-party API is the canonical
+// surface for WhatsApp Business messaging.
+//
+// Inbound:  POST <your-server>/webhooks/whatsapp
+//           — Meta signs the raw body with HMAC-SHA256(WHATSAPP_APP_SECRET)
+//             and sets `X-Hub-Signature-256: sha256=<hex>`.
+//           — receive() must be called with a Request whose body has NOT been
+//             reparsed/reserialized (signature verification needs the exact
+//             raw bytes Meta sent).
+// Inbound verification handshake:
+//           GET <your-server>/webhooks/whatsapp?hub.mode=subscribe&
+//               hub.verify_token=<token>&hub.challenge=<value>
+//           — handled by `verifyWebhook(req)`.
+// Outbound: POST graph.facebook.com/v<version>/<PHONE_NUMBER_ID>/messages
+//           with bearer auth.
+//
+// Env required: WHATSAPP_ACCESS_TOKEN, WHATSAPP_PHONE_NUMBER_ID,
+//               WHATSAPP_APP_SECRET, WHATSAPP_VERIFY_TOKEN.
+
+import { createHmac, timingSafeEqual } from 'node:crypto'
+
+const GRAPH_API_BASE = 'https://graph.facebook.com'
+const GRAPH_API_VERSION = 'v18.0'
+const SIGNATURE_HEADER = 'x-hub-signature-256'
+
+interface MetaTextMessage {
+  from: string
+  id: string
+  type: string
+  text?: { body: string }
+}
+
+interface MetaWebhookEntry {
+  changes?: Array<{
+    value?: {
+      messages?: MetaTextMessage[]
+    }
+  }>
+}
+
+interface MetaWebhookPayload {
+  object?: string
+  entry?: MetaWebhookEntry[]
+}
+
+function readEnv(name: string): string {
+  const v = process.env[name]
+  if (!v) throw new Error(`whatsapp: missing required env var ${name}`)
+  return v
+}
+
+function verifySignature(rawBody: string, headerValue: string | null): boolean {
+  if (!headerValue) return false
+  // Meta sends "sha256=<hex>" — extract the hex digest.
+  const eq = headerValue.indexOf('=')
+  if (eq === -1) return false
+  const algo = headerValue.slice(0, eq)
+  const hex = headerValue.slice(eq + 1)
+  if (algo !== 'sha256' || !/^[0-9a-f]+$/i.test(hex)) return false
+
+  const secret = readEnv('WHATSAPP_APP_SECRET')
+  const expected = createHmac('sha256', secret).update(rawBody, 'utf8').digest('hex')
+  const sigBuf = Buffer.from(hex, 'hex')
+  const expBuf = Buffer.from(expected, 'hex')
+  if (sigBuf.length !== expBuf.length) return false
+  return timingSafeEqual(sigBuf, expBuf)
+}
+
+/** Handle Meta's GET-challenge handshake. Call this from your HTTP server's
+ * GET handler at the same path as the POST webhook. Returns the challenge
+ * string to echo back (200) or null if the verify_token didn't match (403). */
+export function verifyWebhook(req: Request): string | null {
+  const url = new URL(req.url)
+  const mode = url.searchParams.get('hub.mode')
+  const token = url.searchParams.get('hub.verify_token')
+  const challenge = url.searchParams.get('hub.challenge')
+  if (mode !== 'subscribe' || !challenge) return null
+  const expected = readEnv('WHATSAPP_VERIFY_TOKEN')
+  // Constant-time comparison on the verify token.
+  const a = Buffer.from(token ?? '', 'utf8')
+  const b = Buffer.from(expected, 'utf8')
+  if (a.length !== b.length || !timingSafeEqual(a, b)) return null
+  return challenge
+}
+
+/** Parse an inbound Meta webhook POST. Returns null if the request is
+ * unsigned, signature-mismatched, or contains no text message. The first
+ * text message in the payload is returned; multi-message payloads need a
+ * fan-out at the HTTP-server layer. */
+export async function receive(
+  req: Request,
+): Promise<{ chatId: string; text: string; sender: string } | null> {
+  const rawBody = await req.text()
+  const sig = req.headers.get(SIGNATURE_HEADER)
+  if (!verifySignature(rawBody, sig)) return null
+
+  let payload: MetaWebhookPayload
+  try {
+    payload = JSON.parse(rawBody) as MetaWebhookPayload
+  } catch {
+    return null
+  }
+
+  for (const entry of payload.entry ?? []) {
+    for (const change of entry.changes ?? []) {
+      for (const msg of change.value?.messages ?? []) {
+        if (msg.type === 'text' && msg.text?.body) {
+          return { chatId: msg.from, text: msg.text.body, sender: msg.from }
+        }
+      }
+    }
+  }
+  return null
+}
+
+/** Send a text message back to a WhatsApp user. `chatId` is the user's
+ * E.164 phone number (no `+`), as provided by Meta in the inbound payload. */
+export async function send(chatId: string, text: string): Promise<void> {
+  const accessToken = readEnv('WHATSAPP_ACCESS_TOKEN')
+  const phoneNumberId = readEnv('WHATSAPP_PHONE_NUMBER_ID')
+  const url = `${GRAPH_API_BASE}/${GRAPH_API_VERSION}/${encodeURIComponent(phoneNumberId)}/messages`
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${accessToken}`,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      messaging_product: 'whatsapp',
+      recipient_type: 'individual',
+      to: chatId,
+      type: 'text',
+      text: { body: text, preview_url: false },
+    }),
+  })
+
+  if (!res.ok) {
+    const detail = await res.text().catch(() => '')
+    throw new Error(`whatsapp send failed: ${res.status} ${res.statusText} — ${detail.slice(0, 500)}`)
+  }
+}
+
+export const channelMeta = {
+  id: 'whatsapp' as const,
+  envVars: [
+    'WHATSAPP_ACCESS_TOKEN',
+    'WHATSAPP_PHONE_NUMBER_ID',
+    'WHATSAPP_APP_SECRET',
+    'WHATSAPP_VERIFY_TOKEN',
+  ] as const,
+  inbound: 'webhook' as const,
+  outbound: 'POST' as const,
+}

package/registry/layers/agent-channels/whatsapp/manifest.json

@@ -0,0 +1,106 @@
+{
+  "id": "whatsapp",
+  "slot": "agent-channels",
+  "description": "WhatsApp Cloud API channel adapter \u2014 Meta's official Graph API path (NOT Twilio). Provides receive() over webhook with HMAC-SHA256 signature verification (X-Hub-Signature-256 + WHATSAPP_APP_SECRET) and send() via POST to graph.facebook.com/v18.0/<PHONE_NUMBER_ID>/messages with bearer auth. Includes the GET-challenge handshake required by Meta to subscribe a webhook.",
+  "appliesTo": [
+    "agent-runtime-account-executive-ts",
+    "agent-runtime-architect-ts",
+    "agent-runtime-auditor-ts",
+    "agent-runtime-biology-research-ts",
+    "agent-runtime-business-partner-ts",
+    "agent-runtime-career-coach-ts",
+    "agent-runtime-chef-ts",
+    "agent-runtime-chemistry-research-ts",
+    "agent-runtime-cmo-advisor-ts",
+    "agent-runtime-college-counselor-ts",
+    "agent-runtime-cs-research-ts",
+    "agent-runtime-cs-tutor-ts",
+    "agent-runtime-customer-success-ts",
+    "agent-runtime-data-analyst-ts",
+    "agent-runtime-designer-ts",
+    "agent-runtime-devops-ts",
+    "agent-runtime-doctor-ts",
+    "agent-runtime-engineering-manager-ts",
+    "agent-runtime-essay-coach-ts",
+    "agent-runtime-financial-analyst-ts",
+    "agent-runtime-fitness-coach-ts",
+    "agent-runtime-friend-ts",
+    "agent-runtime-game-designer-ts",
+    "agent-runtime-grant-writer-ts",
+    "agent-runtime-history-tutor-ts",
+    "agent-runtime-illustrator-ts",
+    "agent-runtime-language-tutor-ts",
+    "agent-runtime-legal-counsel-ts",
+    "agent-runtime-math-research-ts",
+    "agent-runtime-math-tutor-ts",
+    "agent-runtime-mediator-ts",
+    "agent-runtime-meditation-coach-ts",
+    "agent-runtime-ml-research-ts",
+    "agent-runtime-music-producer-ts",
+    "agent-runtime-novelist-coach-ts",
+    "agent-runtime-nutritionist-ts",
+    "agent-runtime-pentester-ts",
+    "agent-runtime-pharmacist-ts",
+    "agent-runtime-photographer-ts",
+    "agent-runtime-physics-research-ts",
+    "agent-runtime-product-manager-ts",
+    "agent-runtime-real-estate-ts",
+    "agent-runtime-recruiter-ts",
+    "agent-runtime-relationship-coach-ts",
+    "agent-runtime-research",
+    "agent-runtime-sales-engineer-ts",
+    "agent-runtime-screenwriter-ts",
+    "agent-runtime-security-engineer-ts",
+    "agent-runtime-tax-ts",
+    "agent-runtime-therapist-ts",
+    "agent-runtime-travel-planner-ts",
+    "agent-runtime-veterinarian-ts",
+    "agent-runtime-wealth-manager-ts",
+    "multi-agent-creative-studio-ts",
+    "multi-agent-legal-ops-ts",
+    "multi-agent-product-ops-ts",
+    "multi-agent-research-lab-ts",
+    "multi-agent-startup-team-ts"
+  ],
+  "provides": [
+    "channel:whatsapp"
+  ],
+  "defaults": {
+    "channelId": "whatsapp",
+    "graphApiVersion": "v18.0",
+    "graphApiBase": "https://graph.facebook.com",
+    "signatureHeader": "x-hub-signature-256",
+    "envVars": [
+      "WHATSAPP_ACCESS_TOKEN",
+      "WHATSAPP_PHONE_NUMBER_ID",
+      "WHATSAPP_APP_SECRET",
+      "WHATSAPP_VERIFY_TOKEN"
+    ]
+  },
+  "files": [
+    {
+      "source": "files/channels/whatsapp.ts",
+      "target": "channels/whatsapp.ts"
+    },
+    {
+      "source": "files/channels/whatsapp.env.example",
+      "target": "channels/whatsapp.env.example"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "src/channels/whatsapp.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/channels/whatsapp.env.example"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "src/channels/whatsapp.ts"
+    ],
+    "commands": []
+  }
+}