@kalphq/cli 0.0.0-dev-20260416063606 → 0.0.0-dev-20260416083945

package/dist/push-RUBMCAYR.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import {
+  ensureConfig
+} from "./chunk-LAKPXKSS.js";
+
+// src/commands/push.ts
+import { join } from "path";
+import { readFile } from "fs/promises";
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+var LOGO = "\u{1F98B}";
+var push_default = defineCommand({
+  meta: { name: "push", description: "Push an agent to Kalp (preview mode)" },
+  args: {
+    agent: {
+      type: "string",
+      alias: "a",
+      description: "Agent name to push",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const cwd = process.cwd();
+    p.intro(`${LOGO} ${pc.bold("kalp push")}`);
+    const agentName = args.agent;
+    if (!agentName) {
+      p.log.error(`Missing required flag ${pc.cyan("-a <agent-name>")}`);
+      p.outro(pc.dim(`Example: ${pc.cyan("kalp push -a my-agent")}`));
+      process.exit(1);
+    }
+    try {
+      await ensureConfig(cwd);
+    } catch {
+      p.log.error(`${pc.cyan("kalp.config.ts")} not found`);
+      p.outro(pc.dim(`Run ${pc.cyan("kalp init")} first.`));
+      process.exit(1);
+    }
+    const agentPath = join(cwd, "agents", agentName, "index.ts");
+    let agentCode;
+    try {
+      agentCode = await readFile(agentPath, "utf-8");
+    } catch {
+      p.log.error(
+        `Agent ${pc.cyan(agentName)} not found at ${pc.cyan(`agents/${agentName}/index.ts`)}`
+      );
+      process.exit(1);
+    }
+    const s = p.spinner();
+    s.start(`Parsing agent ${pc.cyan(agentName)}`);
+    const defineAgentMatch = agentCode.match(
+      /defineAgent\(\s*(\{[\s\S]*?\})\s*\)/
+    );
+    if (!defineAgentMatch?.[1]) {
+      s.stop(pc.red("Could not parse defineAgent call"));
+      process.exit(1);
+    }
+    const stepMatches = [
+      ...agentCode.matchAll(/createStep\(\s*(\{[\s\S]*?\})\s*\)/g)
+    ];
+    const toolMatches = [
+      ...agentCode.matchAll(/createTool\(\s*(\{[\s\S]*?\})\s*\)/g)
+    ];
+    const steps = stepMatches.map((match, i) => {
+      const content = match[1] ?? "";
+      const idMatch = content.match(/id:\s*["']([^"']+)["']/);
+      const descMatch = content.match(/description:\s*["']([^"']+)["']/);
+      return {
+        id: idMatch?.[1] ?? `step_${i}`,
+        description: descMatch?.[1] ?? ""
+      };
+    });
+    const tools = toolMatches.map((match, i) => {
+      const content = match[1] ?? "";
+      const idMatch = content.match(/id:\s*["']([^"']+)["']/);
+      const descMatch = content.match(/description:\s*["']([^"']+)["']/);
+      return {
+        id: idMatch?.[1] ?? `tool_${i}`,
+        description: descMatch?.[1] ?? ""
+      };
+    });
+    const agentConfig = {
+      name: agentName,
+      source: agentPath,
+      steps,
+      tools
+      // Future: full AST parsing with Zod schema extraction
+    };
+    s.stop("Agent parsed");
+    console.log("\n" + pc.dim("\u2500".repeat(50)));
+    console.log(pc.cyan("Agent Configuration (JSON):"));
+    console.log(pc.dim("\u2500".repeat(50)));
+    console.log(JSON.stringify(agentConfig, null, 2));
+    console.log(pc.dim("\u2500".repeat(50)) + "\n");
+    p.outro(
+      `${LOGO} ${pc.green("Preview ready")} ${pc.dim("\u2014 push to deploy coming soon")}`
+    );
+  }
+});
+export {
+  push_default as default
+};
+//# sourceMappingURL=push-RUBMCAYR.js.map

package/dist/push-RUBMCAYR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/push.ts"],"sourcesContent":["import { join } from \"node:path\";\nimport { readFile } from \"node:fs/promises\";\nimport { defineCommand } from \"citty\";\nimport * as p from \"@clack/prompts\";\nimport pc from \"picocolors\";\nimport { ensureConfig } from \"../utils/fs.js\";\n\nconst LOGO = \"🦋\";\n\nexport default defineCommand({\n  meta: { name: \"push\", description: \"Push an agent to Kalp (preview mode)\" },\n  args: {\n    agent: {\n      type: \"string\",\n      alias: \"a\",\n      description: \"Agent name to push\",\n      required: false,\n    },\n  },\n  async run({ args }) {\n    const cwd = process.cwd();\n\n    p.intro(`${LOGO} ${pc.bold(\"kalp push\")}`);\n\n    // ── Validate agent name ─────────────────────────────────────────────────\n    const agentName = args.agent;\n    if (!agentName) {\n      p.log.error(`Missing required flag ${pc.cyan(\"-a <agent-name>\")}`);\n      p.outro(pc.dim(`Example: ${pc.cyan(\"kalp push -a my-agent\")}`));\n      process.exit(1);\n    }\n\n    // ── Validate kalp.config.ts exists ─────────────────────────────────────\n    try {\n      await ensureConfig(cwd);\n    } catch {\n      p.log.error(`${pc.cyan(\"kalp.config.ts\")} not found`);\n      p.outro(pc.dim(`Run ${pc.cyan(\"kalp init\")} first.`));\n      process.exit(1);\n    }\n\n    // ── Find agent ──────────────────────────────────────────────────────────\n    const agentPath = join(cwd, \"agents\", agentName, \"index.ts\");\n    let agentCode: string;\n    try {\n      agentCode = await readFile(agentPath, \"utf-8\");\n    } catch {\n      p.log.error(\n        `Agent ${pc.cyan(agentName)} not found at ${pc.cyan(`agents/${agentName}/index.ts`)}`,\n      );\n      process.exit(1);\n    }\n\n    const s = p.spinner();\n    s.start(`Parsing agent ${pc.cyan(agentName)}`);\n\n    // ── Parse agent config from TypeScript ──────────────────────────────────\n    // Extract defineAgent({...}) call using regex\n    const defineAgentMatch = agentCode.match(\n      /defineAgent\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)/,\n    );\n    if (!defineAgentMatch?.[1]) {\n      s.stop(pc.red(\"Could not parse defineAgent call\"));\n      process.exit(1);\n    }\n\n    // Extract steps and tools arrays for schema generation\n    const stepMatches = [\n      ...agentCode.matchAll(/createStep\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)/g),\n    ];\n    const toolMatches = [\n      ...agentCode.matchAll(/createTool\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)/g),\n    ];\n\n    const steps = stepMatches.map((match, i) => {\n      const content = match[1] ?? \"\";\n      const idMatch = content.match(/id:\\s*[\"']([^\"']+)[\"']/);\n      const descMatch = content.match(/description:\\s*[\"']([^\"']+)[\"']/);\n      return {\n        id: idMatch?.[1] ?? `step_${i}`,\n        description: descMatch?.[1] ?? \"\",\n      };\n    });\n\n    const tools = toolMatches.map((match, i) => {\n      const content = match[1] ?? \"\";\n      const idMatch = content.match(/id:\\s*[\"']([^\"']+)[\"']/);\n      const descMatch = content.match(/description:\\s*[\"']([^\"']+)[\"']/);\n      return {\n        id: idMatch?.[1] ?? `tool_${i}`,\n        description: descMatch?.[1] ?? \"\",\n      };\n    });\n\n    // ── Build JSON representation ───────────────────────────────────────────\n    const agentConfig = {\n      name: agentName,\n      source: agentPath,\n      steps,\n      tools,\n      // Future: full AST parsing with Zod schema extraction\n    };\n\n    s.stop(\"Agent parsed\");\n\n    // ── Output JSON ─────────────────────────────────────────────────────────\n    console.log(\"\\n\" + pc.dim(\"─\".repeat(50)));\n    console.log(pc.cyan(\"Agent Configuration (JSON):\"));\n    console.log(pc.dim(\"─\".repeat(50)));\n    console.log(JSON.stringify(agentConfig, null, 2));\n    console.log(pc.dim(\"─\".repeat(50)) + \"\\n\");\n\n    p.outro(\n      `${LOGO} ${pc.green(\"Preview ready\")} ${pc.dim(\"— push to deploy coming soon\")}`,\n    );\n  },\n});\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kalphq/cli",
-  "version": "0.0.0-dev-20260416063606",
+  "version": "0.0.0-dev-20260416083945",
   "description": "Zero-config CLI for deploying Kalp agents",
   "type": "module",
   "license": "MIT",
@@ -17,14 +17,16 @@
     "access": "public"
   },
   "dependencies": {
+    "@antfu/ni": "^24.4.0",
     "@clack/prompts": "^0.9.1",
     "citty": "^0.1.6",
     "esbuild": "^0.25.0",
     "giget": "^1.2.3",
-    "nypm": "^0.3.12",
     "picocolors": "^1.1.1",
+    "prettier": "^3.3.3",
     "zod": "^3.25.76",
-    "@kalphq/sdk": "0.0.0-dev-20260416063606"
+    "zod-to-json-schema": "^3.25.76",
+    "@kalphq/sdk": "0.0.0-dev-20260416083945"
   },
   "devDependencies": {
     "@types/node": "^22.15.3",

package/templates/agents/b2b-sales/index.ts

@@ -1,13 +1,21 @@
 import { asAgentId, defineAgent } from "@kalphq/sdk";
 import { scoreLead } from "./steps/score-lead.js";
+import { qualifyProspect } from "./steps/qualify-prospect.js";
 import { enrichCompany } from "./tools/enrich-company.js";
+import { sendSlackNotification } from "./tools/send-slack-notification.js";
+import { crmInbound } from "./webhooks/crm-inbound.js";
+import { stripePayment } from "./webhooks/stripe-payment.js";
+import { hotLeadAlert } from "./signals/hot-lead-alert.js";
+import { dealWon } from "./signals/deal-won.js";
 
 export default defineAgent({
   id: asAgentId("__AGENT_NAME__"),
   name: "__AGENT_NAME__",
   description: "Automates B2B outreach with lead scoring and CRM enrichment.",
-  steps: [scoreLead],
-  tools: [enrichCompany],
+  steps: [scoreLead, qualifyProspect],
+  tools: [enrichCompany, sendSlackNotification],
+  webhooks: [crmInbound, stripePayment],
+  signals: [hotLeadAlert, dealWon],
 
   systemPrompt:
     "You are a B2B sales assistant. Score leads, enrich company data, and draft personalized outreach messages.",
@@ -19,10 +27,31 @@ export default defineAgent({
       return { text: "Lead score too low — skipping outreach." };
     }
 
+    // Qualify the prospect
+    const qualified = await ctx.runStep(qualifyProspect, {
+      company: message.text,
+      score: lead.score,
+      domain: lead.domain,
+    });
+
+    if (!qualified.qualified) {
+      return { text: `Prospect not qualified: ${qualified.reason}` };
+    }
+
     const enriched = await ctx.callTool(enrichCompany, { domain: lead.domain });
 
+    // Notify for high-priority leads
+    if (qualified.priority === "high") {
+      await ctx.callTool(sendSlackNotification, {
+        company: message.text,
+        score: lead.score,
+        domain: lead.domain,
+        channel: "sales-alerts",
+      });
+    }
+
     return {
-      text: `${enriched.companyName} (${lead.score}/100) — Ready for outreach.`,
+      text: `${enriched.companyName} (${lead.score}/100, ${qualified.priority} priority) — Ready for outreach.`,
     };
   },
 });

package/templates/agents/b2b-sales/signals/deal-won.ts

@@ -0,0 +1,31 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal sent when a deal is won for commission tracking
+ */
+export const dealWon = createSignal({
+  id: "deal_won",
+  input: z.object({
+    customerId: z.string(),
+    leadId: z.string().optional(),
+    amount: z.number().optional(),
+    currency: z.string(),
+    source: z.string(),
+    repId: z.string().optional(),
+  }),
+  async handler({ customerId, leadId, amount, currency, source, repId }) {
+    // Signal received - in real implementation this would:
+    // - Update CRM with deal status
+    // - Notify sales manager
+    // - Track commission for rep
+    return {
+      recorded: true,
+      dealId: leadId ?? customerId,
+      amount,
+      currency,
+      source,
+      commissionRep: repId,
+    };
+  },
+});

package/templates/agents/b2b-sales/signals/hot-lead-alert.ts

@@ -0,0 +1,29 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal broadcast when a hot lead is identified
+ */
+export const hotLeadAlert = createSignal({
+  id: "hot_lead_alert",
+  input: z.object({
+    leadId: z.string(),
+    company: z.string(),
+    score: z.number(),
+    email: z.string(),
+    priority: z.string(), // "high", "medium", "low"
+    qualified: z.boolean(),
+  }),
+  async handler({ leadId, company, score, email, priority, qualified }) {
+    // Signal received by other agents (SalesManager, NotificationAgent, etc.)
+    // In real implementation, this would trigger notifications
+    return {
+      acknowledged: true,
+      leadId,
+      company,
+      score,
+      priority,
+      qualified,
+    };
+  },
+});

package/templates/agents/b2b-sales/steps/qualify-prospect.ts

@@ -0,0 +1,50 @@
+import { createStep } from "@kalphq/sdk";
+import { z } from "zod";
+
+export const qualifyProspect = createStep({
+  id: "qualify_prospect",
+  description:
+    "Deep qualification of prospects based on lead score and company data.",
+  input: z.object({
+    company: z.string(),
+    score: z.number(),
+    domain: z.string(),
+  }),
+  output: z.object({
+    qualified: z.boolean(),
+    reason: z.string(),
+    priority: z.string(), // "high" | "medium" | "low"
+  }),
+  async run({ company, score, domain }, ctx) {
+    ctx.logger.info("Qualifying prospect", { company, score, domain });
+
+    // Auto-qualify high scores
+    if (score >= 80) {
+      return {
+        qualified: true,
+        reason: "High engagement score indicates strong interest",
+        priority: "high",
+      };
+    }
+
+    // Qualify medium scores with domain check
+    if (score >= 50) {
+      const isEnterprise =
+        domain.includes("enterprise") || domain.endsWith(".corp");
+      return {
+        qualified: isEnterprise,
+        reason: isEnterprise
+          ? "Enterprise domain with decent engagement"
+          : "Score too low for non-enterprise domain",
+        priority: isEnterprise ? "medium" : "low",
+      };
+    }
+
+    // Low scores - not qualified
+    return {
+      qualified: false,
+      reason: "Low engagement score",
+      priority: "low",
+    };
+  },
+});

package/templates/agents/b2b-sales/tools/send-slack-notification.ts

@@ -0,0 +1,26 @@
+import { createTool } from "@kalphq/sdk";
+import { z } from "zod";
+
+export const sendSlackNotification = createTool({
+  id: "send_slack_notification",
+  description: "Sends a notification to Slack channel for hot leads.",
+  input: z.object({
+    company: z.string(),
+    score: z.number(),
+    domain: z.string(),
+    channel: z.string().default("#sales-hot-leads"),
+  }),
+  async execute({ company, score, domain, channel }, ctx) {
+    ctx.logger.info("Sending Slack notification", { company, score, channel });
+
+    // Replace with actual Slack API call using webhook or bot token
+    // Example: await fetch("https://hooks.slack.com/services/...", {...})
+
+    return {
+      sent: true,
+      channel,
+      message: `🔥 Hot Lead Alert: ${company} (${domain}) scored ${score}/100`,
+      timestamp: new Date().toISOString(),
+    };
+  },
+});

package/templates/agents/b2b-sales/webhooks/crm-inbound.ts

@@ -0,0 +1,27 @@
+import { defineWebhook } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Inbound webhook to receive new lead events from CRM (HubSpot, Salesforce, etc.)
+ */
+export const crmInbound = defineWebhook({
+  id: "crm_inbound",
+  input: z.object({
+    leadId: z.string(),
+    email: z.string().email(),
+    company: z.string(),
+    source: z.string(),
+    metadata: z.record(z.unknown()).optional(),
+  }),
+  async handler({ leadId, email, company, source }) {
+    // Process new lead from CRM
+    // In real implementation, this would trigger agent processing
+    return {
+      success: true,
+      message: "Lead received",
+      leadId,
+      company,
+      source,
+    };
+  },
+});

package/templates/agents/b2b-sales/webhooks/stripe-payment.ts

@@ -0,0 +1,27 @@
+import { defineWebhook } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Stripe webhook for payment events - tracks trial conversions and payments
+ */
+export const stripePayment = defineWebhook({
+  id: "stripe_payment",
+  input: z.object({
+    type: z.string(), // "payment_intent.succeeded", "invoice.paid", etc.
+    customerId: z.string(),
+    amount: z.number().optional(),
+    currency: z.string().default("usd"),
+    metadata: z.record(z.unknown()).optional(),
+  }),
+  async handler({ type, customerId, amount, currency }) {
+    // Process Stripe payment event
+    // In real implementation, this would update CRM and notify agents
+    return {
+      received: true,
+      eventType: type,
+      customerId,
+      amount,
+      currency,
+    };
+  },
+});

package/templates/agents/customer-support/index.ts

@@ -1,13 +1,21 @@
 import { asAgentId, defineAgent } from "@kalphq/sdk";
 import { classifyTicket } from "./steps/classify-ticket.js";
+import { escalateTicket } from "./steps/escalate-ticket.js";
 import { searchKnowledgeBase } from "./tools/search-kb.js";
+import { createJiraIssue } from "./tools/create-jira-issue.js";
+import { slackEscalation } from "./webhooks/slack-escalation.js";
+import { zendeskTicket } from "./webhooks/zendesk-ticket.js";
+import { escalationNeeded } from "./signals/escalation-needed.js";
+import { ticketResolved } from "./signals/ticket-resolved.js";
 
 export default defineAgent({
   id: asAgentId("__AGENT_NAME__"),
   name: "__AGENT_NAME__",
   description: "Handles incoming support tickets with AI-powered routing.",
-  steps: [classifyTicket],
-  tools: [searchKnowledgeBase],
+  steps: [classifyTicket, escalateTicket],
+  tools: [searchKnowledgeBase, createJiraIssue],
+  webhooks: [slackEscalation, zendeskTicket],
+  signals: [escalationNeeded, ticketResolved],
 
   systemPrompt:
     "You are a friendly support agent. Classify tickets, search the knowledge base, and resolve issues efficiently.",
@@ -15,14 +23,38 @@ export default defineAgent({
   async onMessage(message, ctx) {
     const ticket = await ctx.runStep(classifyTicket, { text: message.text });
 
-    if (ticket.category === "billing") {
-      return { text: "Routing to billing team..." };
+    // Check if escalation is needed
+    const escalation = await ctx.runStep(escalateTicket, {
+      category: ticket.category,
+      priority: ticket.priority,
+      sentiment: "neutral", // Could be detected from message
+      previousAttempts: 0,
+    });
+
+    if (escalation.escalate) {
+      // Create Jira issue for technical problems
+      if (ticket.category === "technical") {
+        const jira = await ctx.callTool(createJiraIssue, {
+          summary: `Support Ticket: ${message.text.slice(0, 50)}...`,
+          description: message.text,
+          priority: ticket.priority,
+          reporter: "support-agent",
+        });
+        return {
+          text: `Escalated to engineering team. Issue: ${jira.issueKey}`,
+        };
+      }
+
+      return {
+        text: `Escalating to ${escalation.assignTo}: ${escalation.reason}`,
+      };
     }
 
+    // Try knowledge base for non-escalated issues
     const results = await ctx.callTool(searchKnowledgeBase, {
       query: message.text,
     });
 
-    return { text: results.answer ?? "Let me escalate this to a human agent." };
+    return { text: results.answer ?? "Let me connect you with a specialist." };
   },
 });

package/templates/agents/customer-support/signals/escalation-needed.ts

@@ -0,0 +1,28 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal to alert senior support agents about escalation
+ */
+export const escalationNeeded = createSignal({
+  id: "escalation_needed",
+  input: z.object({
+    ticketId: z.string(),
+    customerId: z.string(),
+    issue: z.string(),
+    priority: z.string(),
+    previousAttempts: z.number(),
+    sentiment: z.string(),
+  }),
+  async handler({ ticketId, customerId, issue, priority, previousAttempts, sentiment }) {
+    // Signal received by senior support agents
+    // In real implementation, this triggers notifications
+
+    return {
+      received: true,
+      ticketId,
+      assignedTier: priority === "high" ? "tier3" : "tier2",
+      estimatedHandleTime: priority === "high" ? "15 min" : "1 hour",
+    };
+  },
+});

package/templates/agents/customer-support/signals/ticket-resolved.ts

@@ -0,0 +1,29 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal broadcast when a ticket is resolved
+ */
+export const ticketResolved = createSignal({
+  id: "ticket_resolved",
+  input: z.object({
+    ticketId: z.string(),
+    customerId: z.string(),
+    resolution: z.string(),
+    satisfaction: z.string(), // "positive", "neutral", "negative"
+    resolutionTime: z.number(), // minutes
+  }),
+  async handler({ ticketId, customerId, resolution, satisfaction, resolutionTime }) {
+    // Broadcast resolution for analytics and notifications
+    // In real implementation, update dashboards and notify customer
+
+    return {
+      recorded: true,
+      ticketId,
+      customerId,
+      satisfaction,
+      resolutionTime,
+      timestamp: new Date().toISOString(),
+    };
+  },
+});

package/templates/agents/customer-support/steps/escalate-ticket.ts

@@ -0,0 +1,53 @@
+import { createStep } from "@kalphq/sdk";
+import { z } from "zod";
+
+export const escalateTicket = createStep({
+  id: "escalate_ticket",
+  description: "Determines if a ticket should be escalated to human support.",
+  input: z.object({
+    category: z.string(), // "billing", "technical", "general"
+    priority: z.string(), // "low", "medium", "high"
+    sentiment: z.string(), // "frustrated", "angry", "neutral", "satisfied"
+    previousAttempts: z.number().default(0),
+  }),
+  output: z.object({
+    escalate: z.boolean(),
+    reason: z.string(),
+    assignTo: z.string(), // "tier1", "tier2", "tier3", "human"
+  }),
+  async run({ category, priority, sentiment, previousAttempts }) {
+    // Auto-escalate frustrated/angry customers with technical issues
+    if ((sentiment === "frustrated" || sentiment === "angry") && category === "technical") {
+      return {
+        escalate: true,
+        reason: "Frustrated customer with technical issue",
+        assignTo: "tier2",
+      };
+    }
+
+    // Escalate high priority billing issues immediately
+    if (priority === "high" && category === "billing") {
+      return {
+        escalate: true,
+        reason: "High priority billing issue",
+        assignTo: "tier3",
+      };
+    }
+
+    // Escalate after multiple failed attempts
+    if (previousAttempts >= 3) {
+      return {
+        escalate: true,
+        reason: `Multiple failed resolution attempts (${previousAttempts})`,
+        assignTo: "human",
+      };
+    }
+
+    // No escalation needed
+    return {
+      escalate: false,
+      reason: "Within agent capabilities",
+      assignTo: "tier1",
+    };
+  },
+});

package/templates/agents/customer-support/tools/create-jira-issue.ts

@@ -0,0 +1,30 @@
+import { createTool } from "@kalphq/sdk";
+import { z } from "zod";
+
+export const createJiraIssue = createTool({
+  id: "create_jira_issue",
+  description: "Creates a bug ticket in Jira for technical issues requiring engineering.",
+  input: z.object({
+    summary: z.string(),
+    description: z.string(),
+    priority: z.string(), // "Low", "Medium", "High", "Critical"
+    component: z.string().optional(),
+    reporter: z.string(),
+  }),
+  async execute({ summary, description, priority, component, reporter }) {
+    // In real implementation, call Jira REST API
+    // POST /rest/api/2/issue
+
+    const issueKey = `PROJ-${Math.floor(Math.random() * 10000)}`;
+
+    return {
+      created: true,
+      issueKey,
+      summary,
+      priority,
+      component: component ?? "General",
+      reporter,
+      url: `https://jira.example.com/browse/${issueKey}`,
+    };
+  },
+});

package/templates/agents/customer-support/webhooks/slack-escalation.ts

@@ -0,0 +1,27 @@
+import { defineWebhook } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Webhook for Slack /escalate command or button
+ */
+export const slackEscalation = defineWebhook({
+  id: "slack_escalation",
+  input: z.object({
+    userId: z.string(),
+    channelId: z.string(),
+    ticketId: z.string(),
+    reason: z.string(),
+    urgency: z.string(), // "low", "medium", "high"
+  }),
+  async handler({ userId, channelId, ticketId, reason, urgency }) {
+    // Process escalation request from Slack
+    // In real implementation, notify on-call support
+
+    return {
+      acknowledged: true,
+      ticketId,
+      escalationId: `ESC-${Date.now()}`,
+      estimatedResponse: urgency === "high" ? "5 minutes" : "30 minutes",
+    };
+  },
+});

package/templates/agents/customer-support/webhooks/zendesk-ticket.ts

@@ -0,0 +1,29 @@
+import { defineWebhook } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Zendesk ticket sync webhook
+ */
+export const zendeskTicket = defineWebhook({
+  id: "zendesk_ticket",
+  input: z.object({
+    ticketId: z.string(),
+    status: z.string(), // "new", "open", "pending", "solved", "closed"
+    subject: z.string(),
+    requesterEmail: z.string(),
+    tags: z.array(z.string()),
+    customFields: z.record(z.unknown()).optional(),
+  }),
+  async handler({ ticketId, status, subject, requesterEmail, tags, customFields }) {
+    // Sync external Zendesk ticket with internal system
+    // In real implementation, update internal ticket store
+
+    return {
+      synced: true,
+      externalId: ticketId,
+      localId: `LOCAL-${ticketId}`,
+      status,
+      tags,
+    };
+  },
+});