@signaliz/sdk 1.0.14 → 1.0.16

package/dist/mcp-config.js

@@ -1229,6 +1229,14 @@ var CAMPAIGN_BUILDER_BUILT_IN_ROUTE_IDS = {
   email_verification: "signaliz-email-verification",
   signals: "signaliz-signals"
 };
+var DEFAULT_CAMPAIGN_BUILDER_APPROVAL_TYPES = [
+  "memory_retrieval",
+  "spend",
+  "customer_tool",
+  "external_write",
+  "delivery",
+  "launch"
+];
 var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
   {
     slug: "cache-first-large-list",
@@ -1728,6 +1736,12 @@ var CampaignBuilderAgent = class {
     });
     return createCampaignBuilderProofReceipt(plan, result);
   }
+  buildKit(options = {}) {
+    return createCampaignBuilderBuildKit(options);
+  }
+  memoryKit(options = {}) {
+    return createCampaignBuilderMemoryKit(options);
+  }
   async commitPlan(plan, options = {}) {
     const writeMode = options.confirm === true && options.dryRun === false;
     if (writeMode && !options.approvedBy) {
@@ -2306,6 +2320,533 @@ function applyCampaignBuilderStrategyTemplate(request) {
     agencyContext: mergeAgencyContext(template.agencyContext, request.agencyContext)
   };
 }
+function createCampaignBuilderAgentRequestTemplate(input = {}) {
+  const builtIns = new Set(input.builtIns ?? DEFAULT_CAMPAIGN_BUILDER_BUILT_INS);
+  if (input.includeLocalLeads) builtIns.add("local_leads");
+  const integrations = input.integrations ?? (input.includeCustomToolPlaceholder ? [createCampaignBuilderToolRoute({
+    provider: "custom_mcp",
+    layer: "enrichment",
+    gtmLayers: ["company_enrichment"],
+    toolName: "workspace_enrich",
+    mcpServerName: "workspace-mcp",
+    label: "Workspace enrichment MCP",
+    mode: "if_available",
+    approvalRequired: true
+  })] : void 0);
+  const preferredProviders = uniqueStrings([
+    ...input.preferredProviders ?? [],
+    ...input.includeNango === false ? [] : ["nango"]
+  ]);
+  const templated = applyCampaignBuilderStrategyTemplate({
+    goal: input.goal || "Build a strategy-template campaign for mature operators in the target ICP.",
+    strategyTemplate: input.strategyTemplate || "non-medical-home-care",
+    campaignName: input.campaignName,
+    accountLabel: input.accountLabel || "Workspace Campaign",
+    accountContext: input.accountContext || "Use private workspace memory, current suppression rules, verified-email quality gates, and approval-gated provider routes.",
+    targetCount: input.targetCount,
+    icp: input.icp ?? {
+      personas: ["Operations leader", "Founder", "Revenue leader"],
+      industries: ["B2B services", "Vertical software", "Local operators"],
+      geographies: ["United States"],
+      keywords: ["growth", "operations", "customer acquisition"],
+      requireVerifiedEmail: true
+    },
+    builtIns: [...builtIns],
+    integrations,
+    customerTools: input.customerTools,
+    preferredProviders,
+    constraints: input.constraints,
+    workspaceContext: input.workspaceContext,
+    brainDefaults: input.brainDefaults,
+    deliveryRisk: input.deliveryRisk,
+    gtmCampaignId: input.gtmCampaignId
+  });
+  return compact({
+    ...templated,
+    memory: mergeMemoryPlan({
+      enabled: true,
+      useWorkspaceHistory: true,
+      useNetworkPatterns: false,
+      privacyMode: "anonymized_patterns",
+      queries: [{
+        query: `${templated.strategyTemplate || "strategy-template"} campaign reply patterns, objections, qualification gates, and verified-email QA`,
+        scopes: ["workspace", "operator_notes"],
+        topK: 10,
+        required: true,
+        rationale: "Load approved private strategy and workflow patterns before campaign planning."
+      }]
+    }, input.memory),
+    agencyContext: mergeAgencyContext({
+      strategyModel: "strategy_template",
+      includeStrategyPatterns: true,
+      includeWorkflowPatterns: true,
+      includeNangoCatalog: true,
+      partnerEcosystem: input.includeNango === false ? ["signaliz"] : ["signaliz", "nango"]
+    }, input.agencyContext),
+    signalizDefaults: mergeSignalizDefaultOverrides({
+      maxCredits: input.signalizDefaults?.maxCredits,
+      delivery: {
+        enabled: true,
+        destinationType: input.signalizDefaults?.delivery?.destinationType ?? "json",
+        approvalRequired: true
+      }
+    }, input.signalizDefaults),
+    approvalPolicy: {
+      requireHumanApproval: true,
+      maxCreditsWithoutApproval: 0,
+      requireApprovalFor: DEFAULT_CAMPAIGN_BUILDER_APPROVAL_TYPES,
+      ...input.approvalPolicy
+    }
+  });
+}
+function createCampaignBuilderBuildKit(input = {}) {
+  const requestFile = input.requestFile || "campaign-request.json";
+  const cliPackage = input.cliPackage || "@signaliz/cli";
+  const sdkPackage = input.sdkPackage || "@signaliz/sdk";
+  const request = createCampaignBuilderAgentRequestTemplate(input);
+  const strategyTemplate = stringValue(request.strategyTemplate) ?? null;
+  const builtIns = request.builtIns ?? DEFAULT_CAMPAIGN_BUILDER_BUILT_INS;
+  const useLocalLeads = builtIns.includes("local_leads");
+  const customRoutes = [
+    ...request.integrations ?? [],
+    ...routesFromCustomerTools(request.customerTools ?? [])
+  ].filter((route) => route.provider !== "signaliz");
+  const strategyFlag = strategyTemplate ? ` --strategy-template ${shellArg(strategyTemplate)}` : "";
+  const targetFlag = request.targetCount ? ` --target-count ${request.targetCount}` : "";
+  const localLeadsFlag = useLocalLeads ? " --use-local-leads" : "";
+  const cliBase = `npx ${cliPackage}`;
+  const sdkCliBase = `npx ${sdkPackage}`;
+  const brief = request.goal || "Build a strategy-template campaign for the target ICP.";
+  const mcpArgs = campaignBuilderBuildKitMcpArgs(request);
+  return {
+    kit_version: "campaign-builder-kit.v1",
+    source: "signaliz.campaignBuilderAgent.buildKit",
+    request_file: requestFile,
+    request,
+    strategy_template: strategyTemplate,
+    built_in_lanes: builtIns,
+    operating_playbooks: getCampaignBuilderOperatingPlaybooksForRequest(request).map((playbook) => playbook.slug),
+    custom_routes: customRoutes.map((route) => ({
+      provider: String(route.provider),
+      layer: String(route.layer),
+      tool: firstNonEmptyString(route.toolName),
+      mcp_server: firstNonEmptyString(route.mcpServerName),
+      mode: route.mode ?? "if_available",
+      approval_required: route.approvalRequired === true || route.mode === "required"
+    })),
+    approval_boundaries: request.approvalPolicy?.requireApprovalFor ?? DEFAULT_CAMPAIGN_BUILDER_APPROVAL_TYPES,
+    byo_tool_pattern: {
+      cli_flag: "--custom-tool provider:layer:tool[:mcp]",
+      request_fragment: createCampaignBuilderToolRoute({
+        provider: "workspace_mcp",
+        layer: "enrichment",
+        gtmLayers: ["company_enrichment"],
+        toolName: "workspace_account_enrich",
+        mcpServerName: "workspace-mcp",
+        label: "Workspace account enrichment",
+        mode: "required",
+        approvalRequired: true
+      })
+    },
+    cli_commands: [
+      {
+        id: "write_request",
+        label: "Write reusable request JSON",
+        command: `${cliBase} campaign-agent init${strategyFlag}${targetFlag}${localLeadsFlag} --output-file ${shellArg(requestFile)}`,
+        safety: "local file only; no MCP calls, credits, provider writes, sender loads, exports, or sends"
+      },
+      {
+        id: "memory_kit",
+        label: "Inspect memory readiness and seed runner",
+        command: `${sdkCliBase} campaign-agent memory-kit${strategyFlag}${targetFlag}${localLeadsFlag} --request-file ${shellArg(requestFile)} --json`,
+        safety: "read-only memory readiness packet plus local seed dry-run commands"
+      },
+      {
+        id: "proof_shortcut",
+        label: "Run no-spend campaign-builder proof",
+        command: `${cliBase} build ${shellArg(brief)}${strategyFlag}${targetFlag}${localLeadsFlag} --json`,
+        safety: "strategy memory, Kernel plan, approvals, and forced build_campaign dry-run only"
+      },
+      {
+        id: "plan",
+        label: "Inspect the full campaign-agent plan",
+        command: `${sdkCliBase} campaign-agent plan --request-file ${shellArg(requestFile)} --json`,
+        safety: "read-only MCP planning and provider-route dry-runs"
+      },
+      {
+        id: "doctor",
+        label: "Check readiness gates",
+        command: `${sdkCliBase} campaign-agent doctor --request-file ${shellArg(requestFile)} --json`,
+        safety: "read-only readiness checks for Memory, Brain, built-ins, BYO routes, and approvals"
+      },
+      {
+        id: "commit_preview",
+        label: "Preview GTM campaign object commit",
+        command: `${sdkCliBase} campaign-agent commit-plan --request-file ${shellArg(requestFile)} --json`,
+        safety: "dry-run commit; writes only with --confirm-write and --approved-by"
+      },
+      {
+        id: "approved_launch",
+        label: "Launch after explicit approval",
+        command: `${sdkCliBase} campaign-agent build-approved --request-file ${shellArg(requestFile)} --confirm-launch --approve-all --approved-by operator@example.com --spend-limit ${request.signalizDefaults?.maxCredits ?? 0} --json`,
+        safety: "spendful path; requires human approval identity, approval types, and spend limit"
+      }
+    ],
+    mcp_calls: [
+      {
+        id: "request_template",
+        tool: "gtm_campaign_agent_request_template",
+        arguments: mcpArgs,
+        safety: "read-only reusable request generation"
+      },
+      {
+        id: "readiness",
+        tool: "gtm_campaign_agent_readiness",
+        arguments: mcpArgs,
+        safety: "read-only preflight across strategy memory, Kernel plan, lanes, routes, and approvals"
+      },
+      {
+        id: "proof",
+        tool: "gtm_campaign_agent_proof",
+        arguments: { ...mcpArgs, idempotency_key: "campaign-agent-proof-001" },
+        safety: "forces build_campaign dry_run=true and confirm_spend=false"
+      },
+      {
+        id: "plan",
+        tool: "gtm_campaign_agent_plan",
+        arguments: mcpArgs,
+        safety: "read-only one-call campaign-agent runbook"
+      },
+      {
+        id: "commit_preview",
+        tool: "gtm_campaign_build_plan_commit",
+        arguments: {
+          name: request.campaignName,
+          campaign_brief: request.goal,
+          lead_count: request.targetCount,
+          dry_run: true,
+          confirm: false
+        },
+        safety: "dry-run commit preview only"
+      }
+    ],
+    sdk_example: {
+      language: "typescript",
+      code: campaignBuilderBuildKitSdkExample(request, requestFile)
+    },
+    verification: [
+      `${cliBase} campaign-agent proof --request-file ${shellArg(requestFile)} --json`,
+      `${cliBase} campaign-agent doctor --request-file ${shellArg(requestFile)} --json`,
+      "Confirm proof.success is true and dry_run_result.status is dry_run before any approved launch.",
+      "Confirm no campaign_build_id exists in a proof receipt before moving to approved launch."
+    ],
+    privacy: {
+      client_names_allowed: false,
+      notes: [
+        "Use strategy templates, operating playbooks, and anonymized workflow patterns instead of client names.",
+        "Do not include raw leads, private replies, domains, secrets, or customer account labels in public kit output."
+      ]
+    },
+    next_actions: [
+      `Write or review ${requestFile}.`,
+      "Run the proof command before spending credits or activating provider writes.",
+      "Add BYO integrations with --custom-tool provider:layer:tool[:mcp] or the request_fragment shape.",
+      "Use build-approved only after human approval, spend limit, and delivery review policy are set."
+    ]
+  };
+}
+function createCampaignBuilderMemoryKit(input = {}) {
+  const requestFile = input.requestFile || "campaign-request.json";
+  const seedManifestFile = input.seedManifestFile || ".gtm-kernel-import-state/campaign-memory-dry-run.json";
+  const cliPackage = input.cliPackage || "@signaliz/cli";
+  const sdkPackage = input.sdkPackage || "@signaliz/sdk";
+  const request = createCampaignBuilderAgentRequestTemplate(input);
+  const strategyTemplate = stringValue(request.strategyTemplate) ?? null;
+  const strategyFlag = strategyTemplate ? ` --strategy-template ${shellArg(strategyTemplate)}` : "";
+  const targetFlag = request.targetCount ? ` --target-count ${request.targetCount}` : "";
+  const localLeadsFlag = request.builtIns?.includes("local_leads") ? " --use-local-leads" : "";
+  const cliBase = `npx ${cliPackage}`;
+  const sdkCliBase = `npx ${sdkPackage}`;
+  const source = campaignBuilderMemoryKitSource(input.source);
+  const workspaceId = input.workspaceId || "your-workspace-id";
+  const brief = request.goal || "Build a strategy-template campaign for the target ICP.";
+  const statusArgs = compact({
+    strategy_template: strategyTemplate,
+    campaign_brief: brief,
+    target_icp: request.icp,
+    include_sources: true,
+    include_samples: false,
+    days: 90,
+    limit: 25
+  });
+  const searchArgs = compact({
+    query: request.memory?.queries?.[0]?.query || brief,
+    layers: ["lead_generation", "email_finding", "email_verification", "company_enrichment", "copy_enrichment"],
+    limit: 10
+  });
+  return {
+    kit_version: "campaign-memory-kit.v1",
+    source: "signaliz.campaignBuilderAgent.memoryKit",
+    read_only: true,
+    no_spend: true,
+    no_provider_writes: true,
+    client_names_allowed: false,
+    request_file: requestFile,
+    seed_manifest_file: seedManifestFile,
+    request,
+    strategy_template: strategyTemplate,
+    operating_playbooks: getCampaignBuilderOperatingPlaybooksForRequest(request).map((playbook) => playbook.slug),
+    memory_sources: source.memorySources,
+    seed_runner: {
+      local_script: "scripts/gtm-kernel/seed-import-runner.mjs",
+      dry_run_command: [
+        "node scripts/gtm-kernel/seed-import-runner.mjs",
+        `--source ${source.seedSource}`,
+        "--dry-run",
+        `--workspace-id ${shellArg(input.workspaceId || "00000000-0000-4000-8000-000000000000")}`,
+        `--manifest ${shellArg(seedManifestFile)}`,
+        "--reset"
+      ].join(" "),
+      verify_manifest_command: source.verifyScript ? `node ${source.verifyScript} ${shellArg(seedManifestFile)}` : null,
+      write_command: `GTM_KERNEL_WORKSPACE_ID=${shellArg(workspaceId)} node scripts/gtm-kernel/seed-import-runner.mjs --source ${source.seedSource} --write`,
+      write_requires: ["SUPABASE_URL", "SUPABASE_SERVICE_ROLE_KEY", "GTM_KERNEL_WORKSPACE_ID", "explicit operator approval"]
+    },
+    cli_commands: [
+      {
+        id: "memory_status",
+        label: "Check strategy memory readiness",
+        command: `${sdkCliBase} gtm strategy-memory${strategyFlag} --brief ${shellArg(brief)} --json`,
+        safety: "read-only MCP memory readiness; no credits, provider writes, sender loads, exports, or sends"
+      },
+      {
+        id: "memory_search",
+        label: "Search ranked campaign memory",
+        command: `${sdkCliBase} gtm memory search --query ${shellArg(String(searchArgs.query || brief))} --limit 10 --json`,
+        safety: "read-only ranked memory lookup"
+      },
+      {
+        id: "seed_dry_run",
+        label: "Dry-run private memory seed import",
+        command: [
+          "node scripts/gtm-kernel/seed-import-runner.mjs",
+          `--source ${source.seedSource}`,
+          "--dry-run",
+          `--workspace-id ${shellArg(input.workspaceId || "00000000-0000-4000-8000-000000000000")}`,
+          `--manifest ${shellArg(seedManifestFile)}`,
+          "--reset"
+        ].join(" "),
+        safety: "local extraction and manifest only; no database writes"
+      },
+      {
+        id: "write_request",
+        label: "Write reusable campaign request JSON",
+        command: `${cliBase} campaign-agent init${strategyFlag}${targetFlag}${localLeadsFlag} --output-file ${shellArg(requestFile)}`,
+        safety: "local file only; no MCP calls, credits, provider writes, sender loads, exports, or sends"
+      },
+      {
+        id: "proof",
+        label: "Run campaign proof after memory check",
+        command: `${cliBase} campaign-agent proof --request-file ${shellArg(requestFile)} --json`,
+        safety: "read-only planning plus forced build_campaign dry-run with confirm_spend=false"
+      }
+    ],
+    mcp_calls: [
+      {
+        id: "strategy_memory_status",
+        tool: "gtm_campaign_strategy_memory_status",
+        arguments: statusArgs,
+        safety: "read-only strategy/workflow memory readiness with sources and no raw samples"
+      },
+      {
+        id: "memory_search",
+        tool: "gtm_memory_search",
+        arguments: searchArgs,
+        safety: "read-only ranked memory lookup"
+      },
+      {
+        id: "campaign_agent_plan",
+        tool: "gtm_campaign_agent_plan",
+        arguments: campaignBuilderBuildKitMcpArgs(request),
+        safety: "read-only campaign-agent plan using built-in Signaliz lanes, memory, Brain, Nango, and BYO routes"
+      },
+      {
+        id: "campaign_agent_proof",
+        tool: "gtm_campaign_agent_proof",
+        arguments: { ...campaignBuilderBuildKitMcpArgs(request), idempotency_key: "campaign-agent-memory-proof-001" },
+        safety: "forces build_campaign dry_run=true and confirm_spend=false after readiness"
+      }
+    ],
+    sdk_example: {
+      language: "typescript",
+      code: campaignBuilderMemoryKitSdkExample(request, seedManifestFile)
+    },
+    privacy: {
+      client_names_allowed: false,
+      notes: [
+        "Use strategy templates, operating playbooks, memory dimensions, and anonymized campaign patterns instead of client names.",
+        "Do not expose raw leads, private replies, domains, secrets, provider payloads, or customer account labels in kit output.",
+        "Seed writes are workspace-private and require explicit operator approval plus Supabase service credentials."
+      ]
+    },
+    next_actions: [
+      "Run memory_status before plan/proof so missing strategy coverage is visible.",
+      `Run seed_dry_run and inspect ${seedManifestFile} before any memory write.`,
+      "Use write_request to save the reusable campaign request, then run proof with no spend.",
+      "Add BYO tools through campaign-agent --custom-tool only after route setup is reviewed."
+    ]
+  };
+}
+function createCampaignBuilderToolRoute(input) {
+  return {
+    provider: input.provider ?? "custom_mcp",
+    layer: input.layer,
+    toolName: input.toolName,
+    mcpServerName: input.mcpServerName,
+    label: input.label,
+    mode: input.mode ?? "if_available",
+    gtmLayer: input.gtmLayer,
+    gtmLayers: input.gtmLayers,
+    approvalRequired: input.approvalRequired ?? input.mode === "required",
+    config: input.config,
+    rationale: `${input.label ?? input.provider ?? "Custom tool"} is a user-provided campaign-builder route for ${input.layer}.`
+  };
+}
+function campaignBuilderBuildKitMcpArgs(request) {
+  return compact({
+    goal: request.goal,
+    campaign_brief: request.goal,
+    campaign_name: request.campaignName,
+    account_label: request.accountLabel,
+    account_context: request.accountContext,
+    strategy_template: request.strategyTemplate,
+    operating_playbooks: request.operatingPlaybooks,
+    target_icp: request.icp,
+    target_count: request.targetCount,
+    builtins: request.builtIns,
+    include_local_leads: request.builtIns?.includes("local_leads") || void 0,
+    preferred_providers: request.preferredProviders,
+    custom_tools: request.integrations?.map((route) => compact({
+      provider: route.provider,
+      layer: route.layer,
+      gtm_layers: route.gtmLayers ?? (route.gtmLayer ? [route.gtmLayer] : void 0),
+      tool: route.toolName,
+      mcp: route.mcpServerName,
+      mode: route.mode,
+      approval_required: route.approvalRequired
+    })),
+    include_nango_catalog: request.agencyContext?.includeNangoCatalog,
+    include_memory: request.memory?.enabled,
+    include_brain: true,
+    include_provider_routes: true,
+    include_delivery_risk: true
+  });
+}
+function campaignBuilderBuildKitSdkExample(request, requestFile) {
+  const proofRequest = {
+    goal: request.goal,
+    strategyTemplate: request.strategyTemplate,
+    targetCount: request.targetCount,
+    builtIns: request.builtIns,
+    integrations: request.integrations
+  };
+  return [
+    "import { Signaliz, createCampaignBuilderBuildKit } from '@signaliz/sdk';",
+    "",
+    `const kit = createCampaignBuilderBuildKit({ requestFile: ${JSON.stringify(requestFile)}, ...${JSON.stringify(proofRequest, null, 2)} });`,
+    "console.log(kit.cli_commands.find((command) => command.id === 'proof_shortcut')?.command);",
+    "",
+    "const signaliz = new Signaliz({ apiKey: process.env.SIGNALIZ_API_KEY! });",
+    "const proof = await signaliz.campaignBuilderAgent.proof(kit.request, {",
+    "  idempotencyKey: `campaign-agent-proof-${Date.now()}`,",
+    "});",
+    "",
+    'if (!proof.success || proof.dry_run_result?.status !== "dry_run") {',
+    "  throw new Error('Campaign proof failed or launched work unexpectedly');",
+    "}"
+  ].join("\n");
+}
+function campaignBuilderMemoryKitSdkExample(request, seedManifestFile) {
+  const input = {
+    goal: request.goal,
+    strategyTemplate: request.strategyTemplate,
+    targetCount: request.targetCount,
+    builtIns: request.builtIns
+  };
+  return [
+    "import { Signaliz, createCampaignBuilderMemoryKit } from '@signaliz/sdk';",
+    "",
+    `const kit = createCampaignBuilderMemoryKit({ seedManifestFile: ${JSON.stringify(seedManifestFile)}, ...${JSON.stringify(input, null, 2)} });`,
+    "console.log(kit.cli_commands.find((command) => command.id === 'memory_status')?.command);",
+    "",
+    "const signaliz = new Signaliz({ apiKey: process.env.SIGNALIZ_API_KEY! });",
+    "const status = await signaliz.gtm.campaignStrategyMemoryStatus({",
+    "  strategyTemplate: kit.request.strategyTemplate,",
+    "  campaignBrief: kit.request.goal,",
+    "  includeSources: true,",
+    "  includeSamples: false,",
+    "});",
+    "",
+    "if (status?.ready === false) {",
+    "  throw new Error('Strategy memory is not ready for this campaign request');",
+    "}"
+  ].join("\n");
+}
+function campaignBuilderMemoryKitSource(source) {
+  const normalized = normalizeTemplateKey(source || "agency");
+  const catalog = {
+    agency: {
+      id: "agency_campaign_builder",
+      label: "Agency campaign-builder strategy patterns",
+      seed_source: "agency",
+      scope: "private_strategy_docs",
+      privacy: "workspace-private sanitized docs and abstracted campaign summaries"
+    },
+    workflow: {
+      id: "workflow_pattern_corpus",
+      label: "Workflow and table-build pattern corpus",
+      seed_source: "building-clay",
+      scope: "read_only_workflow_docs",
+      privacy: "sanitized operating model and workflow patterns"
+    },
+    feedback: {
+      id: "campaign_feedback",
+      label: "Campaign feedback and reply patterns",
+      seed_source: "instantly",
+      scope: "workspace_private_feedback",
+      privacy: "aggregate feedback, reply, and sequence performance memory"
+    }
+  };
+  const sourceMap = {
+    agency: "agency",
+    "campaign-builder": "agency",
+    "strategy-memory": "agency",
+    "workflow-patterns": "workflow",
+    workflow: "workflow",
+    "building-clay": "workflow",
+    clay: "workflow",
+    "instantly-feedback": "feedback",
+    instantly: "feedback",
+    feedback: "feedback",
+    all: "all"
+  };
+  const selected = sourceMap[normalized] || "agency";
+  if (selected === "all") {
+    return {
+      seedSource: "all",
+      verifyScript: null,
+      memorySources: [catalog.agency, catalog.workflow, catalog.feedback]
+    };
+  }
+  const item = catalog[selected];
+  return {
+    seedSource: item.seed_source,
+    verifyScript: item.seed_source === "agency" ? "scripts/gtm-kernel/verify-agency-import-manifest.mjs" : item.seed_source === "building-clay" ? "scripts/gtm-kernel/verify-building-clay-import-manifest.mjs" : null,
+    memorySources: [item]
+  };
+}
+function shellArg(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
 function normalizeTemplateKey(value) {
   return String(value || "").trim().toLowerCase().replace(/[_\s]+/g, "-");
 }

package/dist/mcp-config.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   Signaliz
-} from "./chunk-EVFQETTN.mjs";
+} from "./chunk-5JNKSMNW.mjs";
 
 // src/mcp-config.ts
 import * as fs from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaliz/sdk",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Signaliz SDK — GTM Kernel, Nango routes, MCP, and enrichment for AI agents",
   "main": "dist/index.js",
   "module": "dist/index.mjs",