@zibby/workflow-templates 0.3.0 → 0.4.1

package/browser-test-automation/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.5","results":[[":__tests__/preflight-early-exit.test.mjs",{"duration":6.5747499999999945,"failed":false}]]}

package/browser-test-automation/package.json

@@ -7,6 +7,7 @@
   "main": "graph.mjs",
   "dependencies": {
     "@zibby/core": "^0.5.1",
+    "@zibby/ui-memory": "^1.0.0",
     "zod": "^3.23.0"
   }
 }

package/code-analysis/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.5","results":[[":nodes/__tests__/middleware.integration.test.js",{"duration":0,"failed":true}],[":nodes/__tests__/finalizeNode.test.js",{"duration":8.396791000000007,"failed":false}]]}

package/code-analysis/nodes/generate-code-node.js

@@ -5,8 +5,9 @@
  */
 
 import { spawn } from 'child_process';
-import { join, resolve } from 'path';
+import { dirname, join, resolve } from 'path';
 import { existsSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
 import Handlebars from 'handlebars';
 import { invokeAgent } from '@zibby/core';
 import { generatePRMeta } from './services/prMetaService.js';
@@ -14,6 +15,14 @@ import { adfToText } from '@zibby/core/utils/adf-converter.js';
 import { getRepoPath } from './utils/get-repo-path.js';
 import { z } from 'zod';
 
+// Prompts ship inside the workflow bundle at `<template>/prompts/`.
+// state.promptsDir is the runner-injection slot for callers that want
+// to override (legacy analyze-graph CLI set it explicitly); when unset,
+// resolve relative to this node file so the template is self-contained
+// and works for any runner.
+const __nodeDir = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_PROMPTS_DIR = join(__nodeDir, '..', 'prompts');
+
 const CodeImplementationOutputSchema = z.object({
   success: z.boolean(),
   codeImplementation: z.object({
@@ -60,7 +69,8 @@ export function createCodeGenerationNode(options = {}) {
       const mode = commitAndPush ? 'implementing' : 'generating preview of';
       console.log(`\n💻 ${commitAndPush ? 'Implementing' : 'Generating'} code implementation...`);
       
-      const { workspace, ticketContext, repos, promptsDir, model, nodeConfigs = {} } = state;
+      const { workspace, ticketContext, repos, model, nodeConfigs = {} } = state;
+      const promptsDir = state.promptsDir || DEFAULT_PROMPTS_DIR;
       const aiModel = model || ticketContext.model || 'auto';
       const _nodeConfig = nodeConfigs[nodeName] || {};
       const analysis = state.analyze_ticket?.analysis;

package/index.js

@@ -165,6 +165,142 @@ export const TEMPLATES = {
         'Produce specs that an AI agent can execute end-to-end',
       ],
     },
+  },
+
+  // ── notify-slack: reusable notifier child workflow ────────────────
+  // Dispatched as a sub-graph from any parent that wants Slack alerts.
+  // Single-node graph, no LLM, deterministic API call.
+  'notify-slack': {
+    name: 'notify-slack',
+    displayName: 'Notify Slack',
+    description: 'Reusable child workflow — posts a structured Block Kit alert to a Slack channel. Dispatched by other workflows (Sentry triage, autofix, incident) via sub-graph.',
+    path: join(__dirname, 'notify-slack'),
+    defaultSlug: 'alert-slack',
+    deps: { zod: '^3.23.0' },
+    features: [
+      'Single-node, no LLM — deterministic ~500ms post',
+      'Block Kit message with severity-coded color + emoji',
+      'Optional Sentry-flavored fields (users affected, events, release)',
+      'Action buttons + caller-supplied @-mentions',
+      'Returns messageTs so parent can thread follow-ups',
+    ],
+    marketplace: {
+      slug: 'notify-slack',
+      tagline: 'Reusable Slack alert worker — dispatch from any workflow.',
+      iconPrompt: [
+        'Flat geometric vector illustration with subtle clean gradients, in the spirit of Linear / Notion / Stripe iconography — crisp, no painterly textures.',
+        'Subject: the iconic Slack pinwheel mark — four chunky rounded-rectangle "petals" arranged in a plus / asterisk configuration, colored with Slack\'s signature palette (top-left red #E01E5A, top-right yellow #ECB22E, bottom-right green #2EB67D, bottom-left blue #36C5F0), painted as if it\'s the focal brand mark of the icon. A small bright magenta notification dot floats in the upper-right corner of the pinwheel suggesting an incoming alert/ping.',
+        'Background: deep navy (#0B0F1A) rounded square (1024×1024) with a faint radial glow centered behind the pinwheel so the colors pop without becoming oversaturated.',
+        'Centered composition with the pinwheel as the dominant focal element, the notification dot as a small secondary accent in the upper-right; plenty of breathing room so the silhouette reads at 64×64 in the marketplace grid.',
+        'Mood: focused, energetic, signal-not-noise — the canonical Slack-flavored notification worker.',
+        'NO text, NO letters, NO photo-realism, NO sleek 3D render, NO literal Slack wordmark — the colored pinwheel shape is allowed as the brand reference.',
+      ].join('\n'),
+      category: 'Notifications',
+      tags: ['slack', 'notification', 'alert', 'child-workflow'],
+      capabilities: [
+        'Severity-coded Block Kit message (low/medium/high/critical)',
+        'Code snippet + action button + caller mentions',
+        'Sub-graph dispatchable from any parent workflow',
+        'Returns messageTs for thread replies',
+      ],
+      conversationStarters: [
+        'Post a CRITICAL alert to #incidents from this workflow',
+        'Send a daily summary to #dev-updates',
+        'Notify @oncall when a Sentry issue exceeds threshold',
+        'Forward the deploy-fail message to #ops',
+      ],
+    },
+  },
+
+  // ── notify-lark: same as notify-slack, Lark / Feishu variant ─────
+  'notify-lark': {
+    name: 'notify-lark',
+    displayName: 'Notify Lark',
+    description: 'Reusable child workflow — posts a structured Interactive Card to a Lark / Feishu chat. Dispatched by other workflows via sub-graph.',
+    path: join(__dirname, 'notify-lark'),
+    defaultSlug: 'alert-lark',
+    deps: { zod: '^3.23.0' },
+    features: [
+      'Single-node, no LLM',
+      'Lark Interactive Card with severity template (red/orange/yellow/grey)',
+      'Optional Sentry-flavored metadata fields',
+      'Token cache across multiple sends in one task',
+      'Returns messageId for threaded replies',
+    ],
+    marketplace: {
+      slug: 'notify-lark',
+      tagline: 'Reusable Lark / Feishu alert worker — dispatch from any workflow.',
+      iconPrompt: [
+        'A clean, modern app icon for a Lark / Feishu notification worker.',
+        '',
+        'Visual style: flat geometric vector with subtle gradient, complementary to the notify-slack icon (same family).',
+        'Subject: a stylized speech-bubble silhouette in Lark-cyan-to-blue gradient (#00D6B9 → #1664FF) with a checkmark inside. Gentle motion lines behind it.',
+        'Background: deep navy (#0B0F1A) rounded square (1024×1024).',
+        'Mood: focused, professional, signal-not-noise.',
+        'NO Lark / Feishu logo trademark, NO text, NO photo-realism.',
+      ].join('\n'),
+      category: 'Notifications',
+      tags: ['lark', 'feishu', 'notification', 'alert', 'child-workflow'],
+      capabilities: [
+        'Severity-coded Lark Interactive Card',
+        'Auto-detects receive_id_type from id prefix (chat_id / open_id / email)',
+        'Sub-graph dispatchable from any parent workflow',
+        'Per-process token cache for fan-out efficiency',
+      ],
+      conversationStarters: [
+        'Send a CRITICAL alert to the engineering Lark group',
+        'Notify the on-call group chat when Sentry issue spikes',
+        'Forward deploy notifications to our Lark channel',
+      ],
+    },
+  },
+
+  // ── sentry-triage: parent workflow that uses notify-slack/-lark ──
+  'sentry-triage': {
+    name: 'sentry-triage',
+    displayName: 'Sentry Triage Bot',
+    description: 'Hourly Sentry triage — pulls new issues, drops obvious noise with a regex pre-filter, classifies survivors with LLM (CRITICAL/HIGH/MEDIUM/LOW/NOISE), and fans out alerts to a notify-slack OR notify-lark child workflow.',
+    path: join(__dirname, 'sentry-triage'),
+    defaultSlug: 'sentry-triage',
+    deps: { zod: '^3.23.0' },
+    features: [
+      '4-node graph: fetch → filter_noise → classify → dispatch_alerts',
+      'Regex noise filter before LLM cuts ~80% of classification cost',
+      'LLM severity classifier with explicit rubric (rules 1-5)',
+      'Sub-graph fan-out to notify-slack OR notify-lark (choose at deploy)',
+      'Per-issue failure isolation — one Slack hiccup doesn\'t stall the run',
+      'Configurable severityThreshold (don\'t notify on LOW noise)',
+      'Cron-friendly: hourly schedule, default sinceMinutes=60',
+    ],
+    marketplace: {
+      slug: 'sentry-triage',
+      tagline: 'Filter noise, classify severity, ping the right channel — every hour.',
+      iconPrompt: [
+        'Hand-painted storybook illustration in a warm gouache style with soft brushwork and gentle painterly texture, featuring the friendly round lighthouse mascot character with two big smiling eyes and a rosy blush on its white-and-coral-striped tower body, perched on a tiny mint-green island and clutching a small glowing purple SHIELD BADGE in front of its body — the badge is a rounded geometric emblem in Sentry\'s signature deep violet (#362D59 / #7553FF) with a stylized white "S"-mark inside it formed from overlapping rounded parallelogram shapes, painted with the same soft gouache brushstrokes as the rest of the scene so it feels integrated rather than corporate.',
+        'The lighthouse lantern emits a soft golden beam that catches one glowing amber alert orb while three faded grey noise specks drift harmlessly past, reinforcing the "filter the signal, calm the noise" idea.',
+        'Background is a soft sunrise gradient of pale peach at the top blending through buttercream into a gentle wash of dusty lavender at the base, tying the warm scene to the violet of the badge; a few small fluffy pastel clouds float in for friendliness.',
+        'Centered composition with the purple shield badge as the immediate focal point in the lower-center, the lighthouse rising behind and slightly above it, beam angled diagonally; plenty of breathing room so the silhouette reads at 64×64 with the violet badge clearly visible at a glance.',
+        'Mood is warm, reassuring, optimistic — the friendly Sentry-flavored night-watch character, NOT tactical or corporate or alarming.',
+        'Soft rounded square 1024×1024 canvas with a subtle paper-grain texture.',
+        'NO text, NO letters, NO photo-realism, NO sleek 3D render, NO magnifying glass, NO speech bubbles, NO dark navy or near-black backgrounds, NO bug or insect imagery, NO literal Sentry wordmark.',
+      ].join('\n'),
+      category: 'Operations',
+      tags: ['sentry', 'observability', 'on-call', 'triage', 'alerting'],
+      capabilities: [
+        'Hourly scheduled triage of new Sentry issues',
+        'Deterministic regex filter drops Script error / ResizeObserver / extension noise',
+        'LLM severity classifier with auditable rubric',
+        'Dispatches to notify-slack or notify-lark (sub-graph, ~5ms in-process)',
+        'CRITICAL alerts get caller-supplied @-mentions; lower severities don\'t',
+        'Configurable severity threshold per deploy',
+      ],
+      conversationStarters: [
+        'Triage all new Sentry issues from the last hour',
+        'Notify #sentry-alerts when severity is HIGH or above',
+        'Run hourly and post a summary to our team Slack',
+        'Page on-call when a CRITICAL error appears in checkout',
+      ],
+    },
   }
 };
 

package/notify-lark/README.md

@@ -0,0 +1,88 @@
+# notify-lark
+
+A reusable **child workflow** that posts an Interactive Card alert to a Lark / Feishu chat.
+
+Companion to `notify-slack` — same provider-neutral input shape, so a parent workflow can fan out to BOTH Slack and Lark with the same `input` block (just swap `channel` → `receiveId`).
+
+## What it does
+
+- Takes a provider-neutral payload (severity, title, body, optional Sentry-flavored context)
+- Builds a Lark Interactive Card with severity-coded header template + emoji + action buttons
+- Resolves `tenant_access_token` from the app id/secret stored in your Lark integration
+- POSTs to `/open-apis/im/v1/messages` with the right `receive_id_type` inferred from the id prefix
+
+No LLM call — single deterministic API request, typically <500ms (or <1s on cold token cache).
+
+## Dispatch shape (parent workflow)
+
+```js
+graph.addNode('alert', {
+  workflow: 'notify-lark',
+  async: false,
+  input: (state) => ({
+    severity:   'critical',
+    title:      'Checkout: TypeError on session.user.id',
+    body:       '**12 users** affected in the last 1h. Likely regression from `1.42.0`.',
+    receiveId:  'oc_abc123def456...',                      // chat id, open id, or email
+    sentryLink: 'https://sentry.io/.../1234567890/',
+    affectedUsers: 12,
+    events:     47,
+    release:    '1.42.0',
+    firstSeen:  '8 min ago',
+    codeSnippet:'src/handlers/checkout.ts:142\nconst userId = session.user.id;',
+    mentions:   ['<at user_id="ou_oncall_group">@backend-oncall</at>'],
+  }),
+  output: 'notify_lark.messageId',
+});
+```
+
+## receiveId formats
+
+The `receive_id_type` query param is inferred from the prefix:
+
+| Prefix | Type | Description |
+|---|---|---|
+| `oc_` | `chat_id` | Group chat or DM (most common) |
+| `ou_` | `open_id` | Direct message to a specific user |
+| `on_` | `union_id` | Cross-app stable user id |
+| `cli_` | `app_id` | App-to-app message |
+| `<email>@…` | `email` | Send to user by email |
+
+If you don't know your chat id, DM the bot `whoami` and it'll respond with the caller's `open_id`. Group chat ids appear in the URL when you open the chat in browser.
+
+## Output
+
+```js
+{ delivered: true, receiveId: 'oc_abc...', receiveIdType: 'chat_id', messageId: 'om_xxxxx' }
+```
+
+The `messageId` lets the parent post threaded replies later (e.g. incident-commander progress updates).
+
+## Prerequisites
+
+Project must have the **Lark** integration connected with:
+- `im:message` scope (send messages)
+- `im:message.group_msg` scope (send to group chats)
+
+## Severity → header template
+
+| Severity | Lark template | Emoji |
+|---|---|---|
+| low | `grey` | ⚪ |
+| medium | `yellow` | 🟡 |
+| high | `orange` | 🟠 |
+| critical | `red` | 🚨 |
+
+## Tests
+
+```bash
+cd packages/workflow-templates/notify-lark
+npm test
+```
+
+Tests cover:
+- Card rendering for each severity
+- Conditional sections (fields/body/code/actions only when input present)
+- receive_id_type inference per prefix
+- Tenant token caching across multiple sends
+- Error mapping (invalid receive_id, scope missing, network blip)

package/notify-lark/graph.mjs

@@ -0,0 +1,43 @@
+/**
+ * notify-lark — single-node child workflow.
+ *
+ * Companion to notify-slack; same provider-neutral input shape so a
+ * parent can `dispatchSubgraph('notify-slack')` AND
+ * `dispatchSubgraph('notify-lark')` with the same input block, just
+ * swapping `channel` → `receiveId`. (See notify-slack/graph.mjs for the
+ * Slack-flavored example.)
+ *
+ * Returns `{ delivered, receiveId, receiveIdType, messageId }`. The
+ * `messageId` can be used for thread replies via Lark's reply API in
+ * follow-up dispatches.
+ */
+
+import { WorkflowAgent, WorkflowGraph } from '@zibby/core';
+import { notifyLarkNode } from './nodes/notify-lark-node.js';
+import {
+  notifyLarkInputSchema,
+  notifyLarkContextSchema,
+} from './state.js';
+
+export class NotifyLarkAgent extends WorkflowAgent {
+  buildGraph() {
+    const graph = new WorkflowGraph();
+    graph
+      .setInputSchema(notifyLarkInputSchema)
+      .setContextSchema(notifyLarkContextSchema);
+
+    graph.addNode('notify_lark', notifyLarkNode);
+    graph.setEntryPoint('notify_lark');
+    graph.addEdge('notify_lark', 'END');
+
+    return graph;
+  }
+
+  async onComplete(result) {
+    const delivered = !!result?.state?.notify_lark?.delivered;
+    const mid = result?.state?.notify_lark?.messageId || '?';
+    console.log(`[notify-lark] ${delivered ? 'delivered' : 'failed'} (messageId=${mid})`);
+  }
+}
+
+export default NotifyLarkAgent;

package/notify-lark/nodes/notify-lark-node.js

@@ -0,0 +1,290 @@
+/**
+ * notify-lark node — deterministic, no LLM.
+ *
+ * Sends a Lark Interactive Card via /open-apis/im/v1/messages. Same
+ * design philosophy as notify-slack: parent makes all the decisions
+ * (severity, title, body, who to mention), this node just renders the
+ * card and POSTs it.
+ *
+ * Auth differs from Slack:
+ *   - resolveIntegrationToken('lark') returns { appId, appSecret, host }
+ *     not a ready-to-use bearer token.
+ *   - We exchange app credentials for a `tenant_access_token` via
+ *     /open-apis/auth/v3/tenant_access_token/internal, then use that as
+ *     Bearer auth on the message send. Same flow @zibby/skills/lark.js
+ *     uses; we reimplement here so the node stays decoupled from the
+ *     MCP-tool path (which only the LLM nodes use).
+ *
+ * The token has ~2h TTL — we cache per-process so a parent dispatching
+ * many alerts only pays the auth round-trip once.
+ *
+ * Severity → Lark header template (named themes, not hex):
+ *   low      → grey
+ *   medium   → yellow
+ *   high     → orange
+ *   critical → red
+ *
+ * The Lark API quirk: `content` on the message body must be a
+ * JSON-encoded STRING (not the object itself). Easy to miss.
+ */
+
+import { z } from 'zod';
+import { SKILLS } from '@zibby/core';
+import { resolveIntegrationToken } from '@zibby/core/backend-client.js';
+
+const SEVERITY_TEMPLATE = Object.freeze({
+  low:      'grey',
+  medium:   'yellow',
+  high:     'orange',
+  critical: 'red',
+});
+
+const SEVERITY_EMOJI = Object.freeze({
+  low:      '⚪',
+  medium:   '🟡',
+  high:     '🟠',
+  critical: '🚨',
+});
+
+const NotifyLarkOutputSchema = z.object({
+  delivered: z.boolean(),
+  receiveId: z.string(),
+  receiveIdType: z.string(),
+  messageId: z.string().optional(),
+});
+
+/**
+ * Build the Lark Interactive Card body. Returns the card OBJECT (not
+ * the JSON-stringified form the API expects — callers stringify it).
+ * Exposed for unit tests so we can pin the rendered shape.
+ */
+export function buildLarkCard(input) {
+  const {
+    severity = 'medium',
+    title,
+    body,
+    sentryLink,
+    affectedUsers,
+    events,
+    release,
+    firstSeen,
+    codeSnippet,
+    actionUrl,
+    actionLabel,
+    mentions,
+  } = input;
+
+  const elements = [];
+
+  // Metadata grid — 2-column layout via `is_short: true` on each field.
+  const fields = [];
+  if (typeof affectedUsers === 'number') {
+    fields.push({
+      is_short: true,
+      text: { tag: 'lark_md', content: `**Users affected**\n${affectedUsers}` },
+    });
+  }
+  if (typeof events === 'number') {
+    fields.push({
+      is_short: true,
+      text: { tag: 'lark_md', content: `**Events**\n${events}` },
+    });
+  }
+  if (release) {
+    fields.push({
+      is_short: true,
+      text: { tag: 'lark_md', content: `**Release**\n\`${release}\`` },
+    });
+  }
+  if (firstSeen) {
+    fields.push({
+      is_short: true,
+      text: { tag: 'lark_md', content: `**First seen**\n${firstSeen}` },
+    });
+  }
+  if (fields.length > 0) {
+    elements.push({ tag: 'div', fields });
+  }
+
+  // Body — rendered as lark_md (Lark's markdown variant).
+  if (body && body.trim().length > 0) {
+    elements.push({
+      tag: 'div',
+      text: { tag: 'lark_md', content: body },
+    });
+  }
+
+  // Code snippet — fenced triple-backtick block.
+  if (codeSnippet) {
+    elements.push({
+      tag: 'div',
+      text: { tag: 'lark_md', content: '```\n' + codeSnippet + '\n```' },
+    });
+  }
+
+  // Action buttons — same logic as Slack: primary "Open in Sentry"
+  // when sentryLink set, plus secondary actionUrl/Label pair if both
+  // supplied.
+  const actions = [];
+  if (sentryLink) {
+    actions.push({
+      tag: 'button',
+      text: { tag: 'plain_text', content: 'Open in Sentry' },
+      type: 'primary',
+      url: sentryLink,
+    });
+  }
+  if (actionUrl && actionLabel) {
+    actions.push({
+      tag: 'button',
+      text: { tag: 'plain_text', content: actionLabel.slice(0, 40) },
+      type: 'default',
+      url: actionUrl,
+    });
+  }
+  if (actions.length > 0) {
+    elements.push({ tag: 'action', actions });
+  }
+
+  // Mentions — small-text note at bottom. Caller pre-formatted as
+  // `<at user_id="ou_xxx">@name</at>` strings.
+  if (Array.isArray(mentions) && mentions.length > 0) {
+    elements.push({
+      tag: 'note',
+      elements: [{ tag: 'lark_md', content: mentions.join(' ') }],
+    });
+  }
+
+  const emoji = SEVERITY_EMOJI[severity] || SEVERITY_EMOJI.medium;
+  const template = SEVERITY_TEMPLATE[severity] || SEVERITY_TEMPLATE.medium;
+
+  return {
+    config: { wide_screen_mode: true },
+    header: {
+      template,
+      title: {
+        tag: 'plain_text',
+        content: `${emoji} ${severity.toUpperCase()}  ${title}`.slice(0, 150),
+      },
+    },
+    elements,
+  };
+}
+
+/**
+ * Infer the Lark receive_id_type query param from the id prefix.
+ * Mirrors @zibby/skills/lark.js's inferReceiveIdType — duplicated to
+ * keep the node self-contained.
+ */
+export function inferReceiveIdType(id) {
+  if (!id || typeof id !== 'string') return 'chat_id';
+  if (id.startsWith('oc_')) return 'chat_id';
+  if (id.startsWith('ou_')) return 'open_id';
+  if (id.startsWith('on_')) return 'union_id';
+  if (id.startsWith('cli_')) return 'app_id';
+  if (id.includes('@')) return 'email';
+  return 'chat_id';
+}
+
+// Per-process cache. Tenant access tokens last ~2h; we cache 100m to
+// avoid the boundary case where a 119-min-old token is rejected mid-call.
+const TOKEN_TTL_MS = 100 * 60 * 1000;
+let _tenantTokenCache = null;
+
+async function getTenantAccessToken() {
+  const { appId, appSecret, host } = await resolveIntegrationToken('lark');
+  if (
+    _tenantTokenCache
+    && _tenantTokenCache.appId === appId
+    && _tenantTokenCache.expiresAt > Date.now()
+  ) {
+    return { token: _tenantTokenCache.token, host };
+  }
+  const url = `${host}/open-apis/auth/v3/tenant_access_token/internal`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ app_id: appId, app_secret: appSecret }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (data.code !== 0) {
+    const e = new Error(`Lark tenant_access_token failed: ${data.msg || data.code}`);
+    e.code = data.code;
+    throw e;
+  }
+  _tenantTokenCache = {
+    appId,
+    token: data.tenant_access_token,
+    expiresAt: Date.now() + TOKEN_TTL_MS,
+  };
+  return { token: data.tenant_access_token, host };
+}
+
+/** Test hook — resets the per-process token cache. */
+export function _resetTokenCache() { _tenantTokenCache = null; }
+
+/**
+ * Send the Lark card. Exposed for unit tests so we can stub fetch +
+ * assert payload shape without going through token resolution.
+ */
+export async function postToLark({ token, host, receiveId, receiveIdType, card }) {
+  const url = `${host}/open-apis/im/v1/messages?receive_id_type=${encodeURIComponent(receiveIdType)}`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json; charset=utf-8',
+    },
+    body: JSON.stringify({
+      receive_id: receiveId,
+      msg_type: 'interactive',
+      // Lark wants `content` as a JSON-encoded STRING, not an object.
+      content: JSON.stringify(card),
+    }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (data.code !== 0) {
+    const e = new Error(`Lark send message failed: ${data.msg || `code ${data.code} / http ${res.status}`}`);
+    e.code = data.code || 'unknown';
+    e.status = res.status;
+    throw e;
+  }
+  return { messageId: data.data?.message_id };
+}
+
+export const notifyLarkNode = {
+  name: 'notify_lark',
+  // Declares Lark as a hard requirement for marketplace gating (same
+  // pattern as notify-slack — see that file's comment for rationale).
+  skills: [SKILLS.LARK],
+  outputSchema: NotifyLarkOutputSchema,
+  timeout: 15 * 1000,
+  execute: async (context) => {
+    const state = (context?.state && typeof context.state.getAll === 'function')
+      ? context.state.getAll()
+      : context;
+
+    const receiveId = state.receiveId;
+    if (!receiveId) {
+      throw new Error('notify-lark: input.receiveId is required');
+    }
+    const receiveIdType = inferReceiveIdType(receiveId);
+
+    const { token, host } = await getTenantAccessToken();
+    const card = buildLarkCard(state);
+    const { messageId } = await postToLark({
+      token,
+      host,
+      receiveId,
+      receiveIdType,
+      card,
+    });
+
+    return {
+      delivered: true,
+      receiveId,
+      receiveIdType,
+      messageId,
+    };
+  },
+};

package/notify-lark/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "notify-lark",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "description": "Post a structured alert card to a Lark / Feishu chat — child workflow, dispatched by parent workflows via sub-graph.",
+  "main": "graph.mjs",
+  "scripts": {
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@zibby/core": "^0.5.1",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "vitest": "^2.1.5"
+  }
+}