diff --git a/docs/docs/building/flex-hooks/components.md b/docs/docs/building/flex-hooks/components.md
index a7728cd62..3027c42dc 100644
--- a/docs/docs/building/flex-hooks/components.md
+++ b/docs/docs/building/flex-hooks/components.md
@@ -38,6 +38,7 @@ enum FlexComponent {
   QueueStats = 'QueueStats',
   SideNav = 'SideNav',
   SupervisorTaskCanvasHeader = 'SupervisorTaskCanvasHeader',
+  TaskCanvas = 'TaskCanvas',
   TaskCanvasHeader = 'TaskCanvasHeader',
   TaskCanvasTabs = 'TaskCanvasTabs',
   TaskCard = 'TaskCard',
diff --git a/docs/docs/feature-library/00_overview.md b/docs/docs/feature-library/00_overview.md
index 662030a1d..57185c324 100644
--- a/docs/docs/feature-library/00_overview.md
+++ b/docs/docs/feature-library/00_overview.md
@@ -64,6 +64,7 @@ The **Flex Project Template** comes with a set of features enabled by default wi
 | [Omni Channel Management](omni-channel-capacity-management)  | _method for mixing chat and voice channels_                                                                                                                                |   |
 | [Queues Stats Metrics](queues-stats-metrics)                 | _add custom metrics columns to the Queues View_                                                                                                                            |   |
 | [Ring Notification](ring-notification)                       | _plays a ringtone sound for incoming tasks_                                                                                                                                |   |
+| [Salesforce Integration](salesforce-integration)             | _example starting point for a custom Salesforce integration_                                                                                                               |   |
 | [Scrollable Activities](scrollable-activities)               | _allow the scrolling of the activities list_                                                                                                                               |   |
 | [SIP Support](sip-support)                                   | _adds call control functionality when using a non-WebRTC phone_                                                                                                            |   |
 
diff --git a/docs/docs/feature-library/salesforce-integration.md b/docs/docs/feature-library/salesforce-integration.md
new file mode 100644
index 000000000..185ac7b16
--- /dev/null
+++ b/docs/docs/feature-library/salesforce-integration.md
@@ -0,0 +1,134 @@
+---
+sidebar_label: salesforce-integration
+title: salesforce-integration
+---
+
+## Overview
+
+This feature provides an enhanced Salesforce integration which replaces the out-of-box Salesforce integration plugin. It can be used as a starting point for customizing Salesforce integration functionality, which is not possible when using the out-of-box integration.
+
+Functionality included within this implementation:
+- Activity logging
+  - Creates activity upon task completion or cancellation
+  - Includes agent copilot disposition and summary
+  - Relates the activity to the dialed or screen-popped record, or the agent-selected record
+- Click-to-dial
+- Screen pop
+- UI enhancements
+  - Disables the pop-out and pop-in buttons while on a call, to prevent accidental call hangups
+  - Hides the CRM container when embedded
+  - Hides the Flex logo in the header to make room for additional buttons
+  - Opens the Flex panel automatically when click-to-dial is used or an inbound task is received
+  - Updates the utility bar item icon and label with the worker's current activity (if no tasks), incoming tasks, or the number of active tasks
+  - When screen pop returns multiple records, a dropdown is added to the interface for the agent to select the appropriate record for activity logging
+
+---
+
+Example screenshot of handling an inbound call with UI enhancements and multiple screen pop results:
+
+![Salesforce integration screenshot](/img/features/salesforce-integration/salesforce-integration.png)
+
+---
+
+## Business Details
+
+### Context
+
+Flex includes a Salesforce integration out-of-the-box, however, it is not fully customizable. If the out-of-box integration does not fully meet your needs, you may end up needing to build your own enhanced integration, re-creating the functionality included in the out-of-box integration.
+
+### Objective
+
+This `salesforce-integration` feature aims to be used as a starting point for your own customized Salesforce integration. The feature offers largely the same baseline functionality of the out-of-box integration, as well as some critical usability enhancements:
+
+- Disables the pop-out and pop-in buttons while on a call, to prevent accidental call hangups
+- Interface enhancements that streamline the agent workflow
+- When screen pop returns multiple records, a dropdown is added to the interface for the agent to select the appropriate record for activity logging
+
+### Configuration options
+
+The feature is functional only when Flex is embedded within Salesforce as described [in the Flex documentation](https://www.twilio.com/docs/flex/admin-guide/integrations/salesforce). If the out-of-box Salesforce integration has been [enabled within the Twilio Console](https://console.twilio.com/us1/develop/flex/settings/integrations/salesforce), it must first be disabled.
+
+To enable the feature, under the `flex-config` attributes set the `salesforce_integration` `enabled` flag to `true`.
+
+```json
+"salesforce_integration": {
+  "enabled": true,
+  "activity_logging": true, // Enables the automatic creation of activity records when a task is completed or canceled
+  "click_to_dial": true, // Enables handling click-to-dial within Salesforce
+  "copilot_notes": true, // Adds agent copilot disposition and summary to activity records created by the feature
+  "hide_crm_container": true, // Hides the Flex CRM container when embedded within Salesforce
+  "prevent_popout_during_call": true, // Disables the pop-out or pop-in button while on a call, to prevent accidental hangups
+  "screen_pop": true, // Enables search and screen pop of Salesforce records based on the inbound task attributes
+  "show_panel_automatically": true, // Pops open Flex when a task is received or click-to-dial is performed
+  "utility_bar_status": true // Updates the utility bar item icon and label with the current activity (if no tasks), incoming task, or number of active tasks
+}
+```
+
+#### Screen pop attributes
+
+When an inbound task is accepted, and the `screen_pop` configuration option is set to `true`, the feature will use task attributes in conjunction with the configured [Salesforce softphone layout](https://help.salesforce.com/s/articleView?id=service.cti_admin_phonelayouts.htm&type=5) to determine what record or page is displayed to the agent. Task attributes are used as follows:
+
+1. If the `sfdcObjectId` attribute is present, the Salesforce record ID contained within the attribute will be popped. No other attributes will be used for screen pop when this attribute is present.
+   1. This can be useful when you are performing a data dip to find a record as part of the IVR and want to pop the same record.
+1. Otherwise, a search within Salesforce will be performed, per the softphone layout, using the following task attributes in the following order:
+   1. `name`
+   1. `from`
+   1. `identity`
+   1. `customerAddress`
+
+## Technical Details
+
+The integration uses the [Salesforce Open CTI APIs](https://developer.salesforce.com/docs/atlas.en-us.api_cti.meta/api_cti/sforce_api_cti_intro.htm) and the [Lightning Console API](https://developer.salesforce.com/docs/atlas.en-us.api_console.meta/api_console/sforce_api_console_js_getting_started.htm) to communicate with the Salesforce instance Flex is embedded within.
+
+### Initialization
+
+**File: `utils/SfdcLoader.ts`**
+
+**Flex hook: `pluginsInitialized` event**
+
+Before any integration functionality can be realized, we must first load the appropriate JS libraries from Salesforce. To do so, we load the Open CTI and Console API JS libraries from the Salesforce domain we are embedded within by inserting them as `<script>` elements in the DOM, if they are not already.
+
+### Activity logging
+
+**File: `utils/LogActivity.ts`**
+
+**Flex hooks: `CompleteTask` action, `notesSubmitted` and `taskCanceled` event**
+
+Activity logging is achieved by calling the [OpenCTI `saveLog()` function](https://developer.salesforce.com/docs/atlas.en-us.api_cti.meta/api_cti/sforce_api_cti_savelog_lex.htm) to create a Task record in Salesforce after the agent has completed their handling of the task. This occurs when the agent presses the "Complete" button to complete the task, or when the task that they are handling is canceled (such as by a supervisor or by a failed outbound call).
+
+If agent copilot functionality is enabled, this feature will collect the notes submitted using the `notesSubmitted` event, and will include them in the payload to `saveLog()`. As Salesforce does not include Activity fields out-of-the-box for all copilot data points, such as topics and sentiment, these are not submitted by the feature as-is. However, you may update the payload as desired to pass these into custom fields.
+
+In order to correctly relate the activity log to another record, the `WhatId` or `WhoId` will be passed to `saveLog` based on the value of the task attribute `sfdcObjectId`. This attribute is set automatically by the click-to-dial functionality for outbound tasks, and is also set automatically by the screen pop functionality for inbound tasks when there is a single record match returned by Salesforce. If screen pop returned multiple matches, the user is presented with a dropdown menu in their task canvas, which sets the attribute when a record is selected. The `sfdcObjectType` attribute is used to store the type of object referenced by `sfdcObjectId`, which is then used to determine if the record ID should be passed as the `WhoId` (Contact or Lead) or the `WhatId` (everything else).
+
+:::info Multiple match results handling
+
+As described above, in order to determine the record to relate the activity log to, the user is presented with a dropdown list of records returned from the search results. However, it may be more desirable to instead integrate the selection within the Salesforce interface itself. One approach for achieving this is to use a Lightning Message Service (LMS) channel to publish a message that the Flex plugin can subscribe to and receive. Documentation for subscribing to an LMS channel via the Open CTI library [is available here](https://developer.salesforce.com/docs/atlas.en-us.api_cti.meta/api_cti/sforce_api_cti_methods_lms.htm).
+
+:::
+
+### Click-to-dial
+
+**File: `utils/ClickToDial.ts`**
+
+**Flex hooks: `StartOutboundCall` action, `pluginsInitialized` event**
+
+Click-to-dial is enabled by calling the [OpenCTI `enableClickToDial()` function](https://developer.salesforce.com/docs/atlas.en-us.api_cti.meta/api_cti/sforce_api_cti_enableclicktodial_lex.htm) when the feature initializes, and if successful, passing a callback function to the [OpenCTI `onClickToDial()` function](https://developer.salesforce.com/docs/atlas.en-us.api_cti.meta/api_cti/sforce_api_cti_onclicktodial_lex.htm) for Salesforce to execute when the user clicks on a number to dial.
+
+When performing a click-to-dial, the callback function passed to `onClickToDial()` invokes the `StartOutboundCall` Flex Action to initiate the outbound call. In addition, the [OpenCTI `setSoftphonePanelVisibility()` function](https://developer.salesforce.com/docs/atlas.en-us.api_cti.meta/api_cti/sforce_api_cti_setsoftphonepanelvisibility_lex.htm) is called to pop open the Flex utility bar item.
+
+### Screen pop
+
+**File: `utils/ScreenPop.ts`**
+
+**Flex hook: `AcceptTask` action**
+
+Screen pop is performed whenever the `AcceptTask` action is successfully invoked for inbound tasks. If there is already an `sfdcObjectId` attribute stored on the task, the feature will call the [OpenCTI `screenPop()` function](https://developer.salesforce.com/docs/atlas.en-us.api_cti.meta/api_cti/sforce_api_cti_screenpop_lex.htm) to open the record ID specified in this attribute.
+
+If there is no `sfdcObjectId` attribute stored on the task, the feature will call the [OpenCTI `searchAndScreenPop()` function](https://developer.salesforce.com/docs/atlas.en-us.api_cti.meta/api_cti/sforce_api_cti_searchandscreenpop_lex.htm), passing to it one of the following task attributes in the following order of precedence:
+
+1. `name`
+1. `from`
+1. `identity`
+1. `customerAddress`
+
+Salesforce will then perform a search and screen pop based on the configured [softphone layout settings](https://help.salesforce.com/s/articleView?id=service.cti_admin_phonelayouts.htm&type=5). If a single match result is returned, that record will be saved to task attributes. If multiple match results are found, and activity logging is also enabled, a dropdown will be added to the task canvas for the agent to select the appropriate record from the search results. When selected, the record will be saved to task attributes. The task attributes will then be used for saving associations as part of activity logging.
\ No newline at end of file
diff --git a/docs/static/img/features/salesforce-integration/salesforce-integration.png b/docs/static/img/features/salesforce-integration/salesforce-integration.png
new file mode 100644
index 000000000..b7aa58880
Binary files /dev/null and b/docs/static/img/features/salesforce-integration/salesforce-integration.png differ
diff --git a/flex-config/ui_attributes.common.json b/flex-config/ui_attributes.common.json
index b549b2fb7..34daaf561 100644
--- a/flex-config/ui_attributes.common.json
+++ b/flex-config/ui_attributes.common.json
@@ -426,6 +426,17 @@
         "enabled": false,
         "exclude_attributes": [],
         "exclude_queues": []
+      },
+      "salesforce_integration": {
+        "enabled": false,
+        "activity_logging": true,
+        "click_to_dial": true,
+        "copilot_notes": true,
+        "hide_crm_container": true,
+        "prevent_popout_during_call": true,
+        "screen_pop": true,
+        "show_panel_automatically": true,
+        "utility_bar_status": true
       }
     }
   }
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/config.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/config.ts
new file mode 100644
index 000000000..86e1ec792
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/config.ts
@@ -0,0 +1,50 @@
+import { getFeatureFlags } from '../../utils/configuration';
+import SalesforceIntegrationConfig from './types/ServiceConfiguration';
+
+const {
+  enabled = false,
+  activity_logging = false,
+  click_to_dial = false,
+  copilot_notes = false,
+  hide_crm_container = false,
+  prevent_popout_during_call = false,
+  screen_pop = false,
+  show_panel_automatically = false,
+  utility_bar_status = false,
+} = (getFeatureFlags()?.features?.salesforce_integration as SalesforceIntegrationConfig) || {};
+
+export const isFeatureEnabled = () => {
+  return enabled;
+};
+
+export const isActivityLoggingEnabled = () => {
+  return activity_logging;
+};
+
+export const isClickToDialEnabled = () => {
+  return click_to_dial;
+};
+
+export const isCopilotNotesEnabled = () => {
+  return copilot_notes;
+};
+
+export const isHideCrmContainerEnabled = () => {
+  return hide_crm_container;
+};
+
+export const isPreventPopoutEnabled = () => {
+  return prevent_popout_during_call;
+};
+
+export const isScreenPopEnabled = () => {
+  return screen_pop;
+};
+
+export const isShowPanelAutomaticallyEnabled = () => {
+  return show_panel_automatically;
+};
+
+export const isUtilityBarStatusEnabled = () => {
+  return utility_bar_status;
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/custom-components/AssociateRecordDropdown.tsx b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/custom-components/AssociateRecordDropdown.tsx
new file mode 100644
index 000000000..71d9e837e
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/custom-components/AssociateRecordDropdown.tsx
@@ -0,0 +1,81 @@
+import { Actions, ITask } from '@twilio/flex-ui';
+import { useState } from 'react';
+import { useSelector } from 'react-redux';
+import { Flex } from '@twilio-paste/core/flex';
+import { Select, Option } from '@twilio-paste/core/select';
+
+import AppState from '../../../types/manager/AppState';
+import { reduxNamespace } from '../../../utils/state';
+import { SalesforceIntegrationState } from '../flex-hooks/states';
+import TaskRouterService from '../../../utils/serverless/TaskRouter/TaskRouterService';
+import logger from '../../../utils/logger';
+
+interface AssociateRecordDropdownProps {
+  task?: ITask;
+}
+
+const AssociateRecordDropdown = ({ task }: AssociateRecordDropdownProps) => {
+  const [isSaving, setIsSaving] = useState(false);
+
+  const { screenPopSearchResults } = useSelector(
+    (state: AppState) => state[reduxNamespace].salesforceIntegration as SalesforceIntegrationState,
+  );
+
+  if (!task || !screenPopSearchResults[task.sid]) {
+    return <></>;
+  }
+
+  const recordSelected = async (e: any) => {
+    const sfdcObjectId = e.target.value;
+
+    if (sfdcObjectId === 'placeholder') {
+      return;
+    }
+
+    const record = screenPopSearchResults[task.sid].find((item) => item.id === sfdcObjectId);
+
+    if (!record) {
+      return;
+    }
+
+    const alreadyBlocked = Actions.findBlockedActions('CompleteTask', { task });
+    const shouldBlock = Object.keys(alreadyBlocked).length < 1;
+
+    if (shouldBlock) {
+      Actions.blockAction('CompleteTask', { task });
+    }
+    try {
+      setIsSaving(true);
+      await TaskRouterService.updateTaskAttributes(task.taskSid, { sfdcObjectId, sfdcObjectType: record.type });
+    } catch (error: any) {
+      logger.error('[salesforce-integration] Error updating task attributes with record', error);
+    } finally {
+      setIsSaving(false);
+    }
+    if (shouldBlock) {
+      Actions.unblockAction('CompleteTask', { task });
+    }
+  };
+
+  return (
+    <Flex marginX="space50" marginY="space20">
+      <Select
+        id="associate-record-select"
+        value={task.attributes.sfdcObjectId ?? 'placeholder'}
+        onChange={recordSelected}
+        disabled={isSaving}
+      >
+        <Option disabled value="placeholder">
+          Select a record to associate...
+        </Option>
+        {screenPopSearchResults[task.sid].map((result) => (
+          <Option value={result.id}>
+            {result.name} - {result.type}
+          </Option>
+        ))}
+      </Select>
+    </Flex>
+  );
+};
+
+export default AssociateRecordDropdown;
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/custom-components/StateListener.tsx b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/custom-components/StateListener.tsx
new file mode 100644
index 000000000..f0cbd407c
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/custom-components/StateListener.tsx
@@ -0,0 +1,17 @@
+import { useFlexSelector } from '@twilio/flex-ui';
+import { useEffect } from 'react';
+
+import AppState from '../../../types/manager/AppState';
+import { updateUtilityBar } from '../utils/UtilityBarHelper';
+
+const StateListener = () => {
+  const { activity, tasks } = useFlexSelector((state: AppState) => state.flex.worker);
+
+  useEffect(() => {
+    updateUtilityBar(activity, tasks);
+  }, [activity, tasks]);
+
+  return null;
+};
+
+export default StateListener;
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/AcceptTask.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/AcceptTask.ts
new file mode 100644
index 000000000..907677603
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/AcceptTask.ts
@@ -0,0 +1,35 @@
+import * as Flex from '@twilio/flex-ui';
+
+import { FlexActionEvent, FlexAction } from '../../../../types/feature-loader';
+import { screenPop } from '../../utils/ScreenPop';
+import { getOpenCti } from '../../utils/SfdcHelper';
+import logger from '../../../../utils/logger';
+import { isScreenPopEnabled } from '../../config';
+
+export const actionEvent = FlexActionEvent.after;
+export const actionName = FlexAction.AcceptTask;
+export const actionHook = function screenPopAfterAccept(flex: typeof Flex) {
+  flex.Actions.addListener(`${actionEvent}${actionName}`, async (payload) => {
+    if (!isScreenPopEnabled() || !getOpenCti()) {
+      return;
+    }
+
+    let task;
+
+    if (payload.task) {
+      task = payload.task;
+    } else if (payload.sid) {
+      task = flex.TaskHelper.getTaskByTaskSid(payload.sid);
+    }
+
+    if (!task) {
+      return;
+    }
+
+    try {
+      screenPop(task);
+    } catch (error: any) {
+      logger.error('[salesforce-integration] Error calling Open CTI screenPop', error);
+    }
+  });
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/SetActivity.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/SetActivity.ts
new file mode 100644
index 000000000..97b31c526
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/SetActivity.ts
@@ -0,0 +1,12 @@
+import * as Flex from '@twilio/flex-ui';
+
+import { FlexActionEvent, FlexAction } from '../../../../types/feature-loader';
+import { SalesforceIntegrationNotification } from '../notifications';
+
+export const actionEvent = FlexActionEvent.after;
+export const actionName = FlexAction.SetActivity;
+export const actionHook = function clearNotificationAfterSetActivity(flex: typeof Flex) {
+  flex.Actions.addListener(`${actionEvent}${actionName}`, async () => {
+    flex.Notifications.dismissNotificationById(SalesforceIntegrationNotification.UnableToCallOffline);
+  });
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/afterCompleteTask.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/afterCompleteTask.ts
new file mode 100644
index 000000000..39b1d2778
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/afterCompleteTask.ts
@@ -0,0 +1,43 @@
+import * as Flex from '@twilio/flex-ui';
+
+import { FlexActionEvent, FlexAction } from '../../../../types/feature-loader';
+import { saveLog } from '../../utils/LogActivity';
+import { getOpenCti } from '../../utils/SfdcHelper';
+import logger from '../../../../utils/logger';
+import { isActivityLoggingEnabled } from '../../config';
+
+export const actionEvent = FlexActionEvent.after;
+export const actionName = FlexAction.CompleteTask;
+export const actionHook = function saveCallLog(flex: typeof Flex) {
+  flex.Actions.addListener(`${actionEvent}${actionName}`, async (payload) => {
+    if (!isActivityLoggingEnabled() || !getOpenCti()) {
+      return;
+    }
+
+    let task;
+
+    if (payload.task) {
+      task = payload.task;
+    } else if (payload.sid) {
+      task = flex.TaskHelper.getTaskByTaskSid(payload.sid);
+    }
+
+    if (!task) {
+      return;
+    }
+
+    try {
+      logger.log(`[salesforce-integration] Saving task log for ${task.taskSid}`);
+      saveLog(task, 'Completed', (response: any) => {
+        if (response.success) {
+          logger.log('[salesforce-integration] Saved task log', response.returnValue);
+          (window as any).sforce.opencti.refreshView();
+          return;
+        }
+        logger.error('[salesforce-integration] Unable to save task log', response.errors);
+      });
+    } catch (error: any) {
+      logger.error('[salesforce-integration] Error calling Open CTI saveLog', error);
+    }
+  });
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/beforeCompleteTask.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/beforeCompleteTask.ts
new file mode 100644
index 000000000..03b4e915f
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/actions/beforeCompleteTask.ts
@@ -0,0 +1,44 @@
+import * as Flex from '@twilio/flex-ui';
+
+import { FlexActionEvent, FlexAction } from '../../../../types/feature-loader';
+import { getOpenCti } from '../../utils/SfdcHelper';
+import logger from '../../../../utils/logger';
+import { isActivityLoggingEnabled, isScreenPopEnabled } from '../../config';
+import { reduxNamespace } from '../../../../utils/state';
+import { AppState } from '../../../../types/manager';
+import { SalesforceIntegrationNotification } from '../notifications';
+
+export const actionEvent = FlexActionEvent.before;
+export const actionName = FlexAction.CompleteTask;
+export const actionHook = function checkRecordAssociation(flex: typeof Flex, manager: Flex.Manager) {
+  flex.Actions.addListener(`${actionEvent}${actionName}`, async (payload, abortFunction) => {
+    if (!isActivityLoggingEnabled() || !isScreenPopEnabled() || !getOpenCti()) {
+      return;
+    }
+
+    let task;
+
+    if (payload.task) {
+      task = payload.task;
+    } else if (payload.sid) {
+      task = flex.TaskHelper.getTaskByTaskSid(payload.sid);
+    }
+
+    if (!task) {
+      return;
+    }
+
+    if (
+      !task.attributes.sfdcObjectId &&
+      (manager.store.getState() as AppState)[reduxNamespace].salesforceIntegration.screenPopSearchResults[task.sid]
+        ?.length
+    ) {
+      // If no record ID saved, but search results in Redux, abort and notify
+      flex.Notifications.showNotification(SalesforceIntegrationNotification.AssociationRequired);
+      logger.warn(
+        '[salesforce-integration] Task completion prevented while waiting for user to select record to associate',
+      );
+      abortFunction();
+    }
+  });
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/components/MainHeader.tsx b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/components/MainHeader.tsx
new file mode 100644
index 000000000..d5593ee92
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/components/MainHeader.tsx
@@ -0,0 +1,22 @@
+import * as Flex from '@twilio/flex-ui';
+
+import StateListener from '../../custom-components/StateListener';
+import { FlexComponent } from '../../../../types/feature-loader';
+import { isUtilityBarStatusEnabled } from '../../config';
+import { isSalesforce, getSfdcBaseUrl } from '../../utils/SfdcHelper';
+
+export const componentName = FlexComponent.MainHeader;
+export const componentHook = function addUtilityBarStateListener(flex: typeof Flex) {
+  if (!isSalesforce(getSfdcBaseUrl())) {
+    // Open CTI isn't loaded yet, so just check that we are embedded within Salesforce
+    return;
+  }
+
+  // When embedded in Salesforce, there is no room for the logo and it obscures other buttons added to the header.
+  flex.MainHeader.Content.remove('logo');
+
+  if (!isUtilityBarStatusEnabled()) {
+    return;
+  }
+  flex.MainHeader.Content.add(<StateListener key="utility-bar-state-listener" />);
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/components/TaskCanvas.tsx b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/components/TaskCanvas.tsx
new file mode 100644
index 000000000..ef7a65286
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/components/TaskCanvas.tsx
@@ -0,0 +1,16 @@
+import * as Flex from '@twilio/flex-ui';
+
+import AssociateRecordDropdown from '../../custom-components/AssociateRecordDropdown';
+import { FlexComponent } from '../../../../types/feature-loader';
+import { isActivityLoggingEnabled, isScreenPopEnabled } from '../../config';
+import { isSalesforce, getSfdcBaseUrl } from '../../utils/SfdcHelper';
+
+export const componentName = FlexComponent.TaskCanvas;
+export const componentHook = function addAsssociateRecordDropdownToCanvas(flex: typeof Flex) {
+  if (!isActivityLoggingEnabled() || !isScreenPopEnabled() || !isSalesforce(getSfdcBaseUrl())) {
+    return;
+  }
+  flex.TaskCanvas.Content.add(<AssociateRecordDropdown key="associate-record-dropdown" />, {
+    sortOrder: 1,
+  });
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/notesSubmitted.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/notesSubmitted.ts
new file mode 100644
index 000000000..5c871e0b1
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/notesSubmitted.ts
@@ -0,0 +1,25 @@
+import * as Flex from '@twilio/flex-ui';
+
+import { FlexEvent } from '../../../../types/feature-loader';
+import { setChannelNote } from '../states';
+import logger from '../../../../utils/logger';
+import { isCopilotNotesEnabled } from '../../config';
+
+export const eventName = FlexEvent.notesSubmitted;
+export const eventHook = async function collectCopilotNotes(flex: typeof Flex, manager: Flex.Manager, notes: any) {
+  if (!isCopilotNotesEnabled()) {
+    return;
+  }
+  logger.log('[salesforce-integration] Received agent copilot wrapup summary', notes);
+  manager.store.dispatch(
+    setChannelNote({
+      channelSid: notes.channelSid,
+      dispositionCode: {
+        disposition_code: notes.dispositionCode.disposition_code,
+        topic_path: notes.dispositionCode.topic_path,
+      },
+      sentiment: notes.sentiment,
+      summary: notes.summary,
+    }),
+  );
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/pluginsInitialized.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/pluginsInitialized.ts
new file mode 100644
index 000000000..5b925da32
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/pluginsInitialized.ts
@@ -0,0 +1,57 @@
+import * as Flex from '@twilio/flex-ui';
+
+import { initializeSalesforceAPIs } from '../../utils/SfdcLoader';
+import { FlexEvent } from '../../../../types/feature-loader';
+import { getSfdcBaseUrl, isSalesforce } from '../../utils/SfdcHelper';
+import { enableClickToDial } from '../../utils/ClickToDial';
+import logger from '../../../../utils/logger';
+import { isClickToDialEnabled, isHideCrmContainerEnabled, isUtilityBarStatusEnabled } from '../../config';
+import { updateUtilityBar } from '../../utils/UtilityBarHelper';
+
+export const eventName = FlexEvent.pluginsInitialized;
+export const eventHook = async function loadOpenCti(flex: typeof Flex, manager: Flex.Manager) {
+  if (isSalesforce(getSfdcBaseUrl()) && isHideCrmContainerEnabled()) {
+    // Hide Flex's own CRM container while we are embedded within Salesforce
+    manager.updateConfig({
+      componentProps: {
+        AgentDesktopView: {
+          showPanel2: false,
+        },
+      },
+    });
+  }
+
+  let openCtiLoaded = false;
+  try {
+    openCtiLoaded = await initializeSalesforceAPIs();
+  } catch (error: any) {
+    logger.error('[salesforce-integration] Error initializing Open CTI', error);
+  }
+
+  if (!openCtiLoaded) {
+    return;
+  }
+  logger.log('[salesforce-integration] Open CTI loaded');
+
+  if (!isClickToDialEnabled()) {
+    return;
+  }
+
+  try {
+    logger.log('[salesforce-integration] Enabling click-to-dial');
+    enableClickToDial();
+  } catch (error: any) {
+    logger.error('[salesforce-integration] Error calling Open CTI enableClickToDial', error);
+  }
+
+  if (!isUtilityBarStatusEnabled()) {
+    return;
+  }
+
+  try {
+    const { activity, tasks } = manager.store.getState().flex.worker;
+    updateUtilityBar(activity, tasks);
+  } catch (error: any) {
+    logger.error('[salesforce-integration] Error calling Open CTI to update utility bar', error);
+  }
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/taskCanceled.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/taskCanceled.ts
new file mode 100644
index 000000000..9ab557b43
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/taskCanceled.ts
@@ -0,0 +1,26 @@
+import * as Flex from '@twilio/flex-ui';
+
+import { FlexEvent } from '../../../../types/feature-loader';
+import { saveLog } from '../../utils/LogActivity';
+import { getOpenCti } from '../../utils/SfdcHelper';
+import logger from '../../../../utils/logger';
+
+export const eventName = FlexEvent.taskCanceled;
+export const eventHook = function saveCanceledCallLog(flex: typeof Flex, manager: Flex.Manager, task: Flex.ITask) {
+  try {
+    if (!getOpenCti()) {
+      return;
+    }
+    logger.log(`[salesforce-integration] Saving canceled task log for ${task.taskSid}`);
+    saveLog(task, 'Canceled', (response: any) => {
+      if (response.success) {
+        logger.log('[salesforce-integration] Saved canceled task log', response.returnValue);
+        (window as any).sforce.opencti.refreshView();
+        return;
+      }
+      logger.error('[salesforce-integration] Unable to save canceled task log', response.errors);
+    });
+  } catch (error: any) {
+    logger.error('[salesforce-integration] Error calling Open CTI saveLog', error);
+  }
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/taskReceived.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/taskReceived.ts
new file mode 100644
index 000000000..a87d35011
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/events/taskReceived.ts
@@ -0,0 +1,18 @@
+import { FlexEvent } from '../../../../types/feature-loader';
+import { getOpenCti } from '../../utils/SfdcHelper';
+import { setSoftphonePanelVisibility } from '../../utils/UtilityBarHelper';
+import logger from '../../../../utils/logger';
+import { isShowPanelAutomaticallyEnabled } from '../../config';
+
+export const eventName = FlexEvent.taskReceived;
+export const eventHook = function popPanelOnTaskReceived() {
+  if (!isShowPanelAutomaticallyEnabled() || !getOpenCti()) {
+    return;
+  }
+
+  try {
+    setSoftphonePanelVisibility(true);
+  } catch (error: any) {
+    logger.error('[salesforce-integration] Error calling Open CTI to set softphone panel visibility', error);
+  }
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/jsclient-event-listeners/voice-client/incoming.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/jsclient-event-listeners/voice-client/incoming.ts
new file mode 100644
index 000000000..4ee5d16d8
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/jsclient-event-listeners/voice-client/incoming.ts
@@ -0,0 +1,28 @@
+import * as Flex from '@twilio/flex-ui';
+import { Call } from '@twilio/voice-sdk';
+
+import { FlexJsClient, VoiceEvent } from '../../../../../types/feature-loader';
+import { getConsole } from '../../../utils/SfdcHelper';
+import logger from '../../../../../utils/logger';
+import { isPreventPopoutEnabled } from '../../../config';
+
+export const clientName = FlexJsClient.voiceClient;
+export const eventName = VoiceEvent.incoming;
+export const jsClientHook = (_flex: typeof Flex, manager: Flex.Manager, call: Call) => {
+  if (!isPreventPopoutEnabled() || !getConsole()) {
+    // We cannot do anything if the console API has not been loaded or if this functionality is disabled
+    return;
+  }
+
+  getConsole().setCustomConsoleComponentPopoutable(false, (result: any) => {
+    logger.log(`[salesforce-integration] Disable popoutable ${result.success ? 'successful' : 'failed'}`);
+  });
+
+  for (const event of ['cancel', 'disconnect', 'error', 'reject']) {
+    call.on(event, () => {
+      getConsole().setCustomConsoleComponentPopoutable(true, (result: any) => {
+        logger.log(`[salesforce-integration] Enable popoutable ${result.success ? 'successful' : 'failed'}`);
+      });
+    });
+  }
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/notifications/index.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/notifications/index.ts
new file mode 100644
index 000000000..9e6116cf8
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/notifications/index.ts
@@ -0,0 +1,32 @@
+import * as Flex from '@twilio/flex-ui';
+
+import { StringTemplates } from '../strings';
+
+// Export the notification IDs an enum for better maintainability when accessing them elsewhere
+export enum SalesforceIntegrationNotification {
+  AssociationRequired = 'PSSalesforceAssociationRequired',
+  AlreadyOnPhone = 'PSSalesforceAlreadyOnPhone',
+  UnableToCallOffline = 'PSSalesforceUnableToCallOffline',
+}
+
+// Return an array of Flex.Notification
+export const notificationHook = () => [
+  {
+    id: SalesforceIntegrationNotification.AssociationRequired,
+    type: Flex.NotificationType.error,
+    content: StringTemplates.AssociationRequired,
+    timeout: 3500,
+  },
+  {
+    id: SalesforceIntegrationNotification.AlreadyOnPhone,
+    type: Flex.NotificationType.error,
+    content: StringTemplates.AlreadyOnPhone,
+    timeout: 3500,
+  },
+  {
+    id: SalesforceIntegrationNotification.UnableToCallOffline,
+    type: Flex.NotificationType.error,
+    content: StringTemplates.UnableToCallOffline,
+    timeout: 5000,
+  },
+];
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/states/index.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/states/index.ts
new file mode 100644
index 000000000..65630b9f0
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/states/index.ts
@@ -0,0 +1,58 @@
+import { createSlice } from '@reduxjs/toolkit';
+import type { PayloadAction } from '@reduxjs/toolkit';
+
+export interface ChannelNote {
+  channelSid: string;
+  dispositionCode: {
+    topic_path: string;
+    disposition_code: string;
+  };
+  sentiment: string;
+  summary: string;
+}
+
+export interface ScreenPopSearchResult {
+  id: string;
+  type: string;
+  name: string;
+}
+
+export interface ScreenPopSearchResultsPayload {
+  reservationSid: string;
+  results: ScreenPopSearchResult[];
+}
+
+export interface SalesforceIntegrationState {
+  channelNotes: { [channelSid: string]: ChannelNote };
+  screenPopSearchResults: { [reservationSid: string]: ScreenPopSearchResult[] };
+}
+
+const initialState = {
+  channelNotes: {},
+  screenPopSearchResults: {},
+} as SalesforceIntegrationState;
+
+const salesforceIntegrationSlice = createSlice({
+  name: 'salesforceIntegration',
+  initialState,
+  reducers: {
+    setChannelNote(state, action: PayloadAction<ChannelNote>) {
+      state.channelNotes[action.payload.channelSid] = action.payload;
+    },
+    clearChannelNote(state, action: PayloadAction<string>) {
+      if (!state.channelNotes[action.payload]) return;
+      delete state.channelNotes[action.payload];
+    },
+    setSearchResults(state, action: PayloadAction<ScreenPopSearchResultsPayload>) {
+      state.screenPopSearchResults[action.payload.reservationSid] = action.payload.results;
+    },
+    clearSearchResults(state, action: PayloadAction<string>) {
+      if (!state.screenPopSearchResults[action.payload]) return;
+      delete state.screenPopSearchResults[action.payload];
+    },
+  },
+});
+
+export const { setChannelNote, clearChannelNote, setSearchResults, clearSearchResults } =
+  salesforceIntegrationSlice.actions;
+export const reducerHook = () => ({ salesforceIntegration: salesforceIntegrationSlice.reducer });
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/strings/index.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/strings/index.ts
new file mode 100644
index 000000000..91b67234a
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/flex-hooks/strings/index.ts
@@ -0,0 +1,19 @@
+// Export the template names as an enum for better maintainability when accessing them elsewhere
+export enum StringTemplates {
+  AssociationRequired = 'PSSalesforceAssociationRequired',
+  AlreadyOnPhone = 'PSSalesforceAlreadyOnPhone',
+  IncomingTaskLabel = 'PSSalesforceIncomingTaskLabel',
+  TasksLabel = 'PSSalesforceTasksLabel',
+  UnableToCallOffline = 'PSSalesforceUnableToCallOffline',
+}
+
+export const stringHook = () => ({
+  'en-US': {
+    [StringTemplates.AssociationRequired]: 'Please select a Salesforce record to associate before completing the task.',
+    [StringTemplates.AlreadyOnPhone]: 'You must end your current call before placing a new call.',
+    [StringTemplates.IncomingTaskLabel]: 'Incoming Task',
+    [StringTemplates.TasksLabel]: '{{numTasks}} {{#if singular}}Task{{else}}Tasks{{/if}}',
+    [StringTemplates.UnableToCallOffline]:
+      'You must change to an activity other than "{{activity}}" before placing a new call.',
+  },
+});
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/index.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/index.ts
new file mode 100644
index 000000000..c8aac8778
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/index.ts
@@ -0,0 +1,9 @@
+import { FeatureDefinition } from '../../types/feature-loader';
+import { isFeatureEnabled } from './config';
+// @ts-ignore
+import hooks from './flex-hooks/**/*.*';
+
+export const register = (): FeatureDefinition => {
+  if (!isFeatureEnabled()) return {};
+  return { name: 'salesforce-integration', hooks: typeof hooks === 'undefined' ? [] : hooks };
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/types/ServiceConfiguration.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/types/ServiceConfiguration.ts
new file mode 100644
index 000000000..6befe5d35
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/types/ServiceConfiguration.ts
@@ -0,0 +1,11 @@
+export default interface SalesforceIntegrationConfig {
+  enabled: boolean;
+  activity_logging: boolean;
+  click_to_dial: boolean;
+  copilot_notes: boolean;
+  hide_crm_container: boolean;
+  prevent_popout_during_call: boolean;
+  screen_pop: boolean;
+  show_panel_automatically: boolean;
+  utility_bar_status: boolean;
+}
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/ClickToDial.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/ClickToDial.ts
new file mode 100644
index 000000000..0628f8507
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/ClickToDial.ts
@@ -0,0 +1,88 @@
+import { Actions, Manager, Notifications, StateHelper } from '@twilio/flex-ui';
+
+import { getOpenCti } from './SfdcHelper';
+import logger from '../../../utils/logger';
+import { SalesforceIntegrationNotification } from '../flex-hooks/notifications';
+import { setSoftphonePanelVisibility } from './UtilityBarHelper';
+import { isShowPanelAutomaticallyEnabled } from '../config';
+
+const handleClickToDial = async (response: any) => {
+  logger.log('[salesforce-integration] Performing click-to-dial', response);
+
+  const manager = Manager.getInstance();
+
+  // Check that this is the active Flex session
+  const { singleSessionGuard } = manager.store.getState().flex.session;
+  if (singleSessionGuard?.sessionInvalidated || singleSessionGuard?.otherSessionDetected) {
+    logger.error(
+      '[salesforce-integration] Outbound call not made as Flex session not valid per single session guard',
+      singleSessionGuard,
+    );
+    return;
+  }
+
+  if (isShowPanelAutomaticallyEnabled()) {
+    // If the Flex softphone is not visible, make it so
+    // We do this here instead of relying on taskReceived so that the user can see any error notifications
+    setSoftphonePanelVisibility(true);
+  }
+
+  // Check that the worker is not already on a call
+  if (StateHelper.getCurrentPhoneCallState() || StateHelper.hasPendingCall()) {
+    Notifications.dismissNotificationById(SalesforceIntegrationNotification.AlreadyOnPhone);
+    Notifications.showNotification(SalesforceIntegrationNotification.AlreadyOnPhone);
+    logger.error('[salesforce-integration] Outbound call not made as user is already on a call');
+    return;
+  }
+
+  // Check that the worker is not offline
+  const workerActivity = manager.store.getState().flex.worker?.activity;
+  if (workerActivity?.sid === manager.serviceConfiguration.taskrouter_offline_activity_sid) {
+    Notifications.dismissNotificationById(SalesforceIntegrationNotification.UnableToCallOffline);
+    Notifications.showNotification(SalesforceIntegrationNotification.UnableToCallOffline, {
+      activity: workerActivity?.name,
+    });
+    logger.error('[salesforce-integration] Outbound call not made as user is in the offline activity');
+    return;
+  }
+
+  let sfdcObjectId = response.recordId;
+  let sfdcObjectType = response.objectType;
+
+  if (response.personAccount && response.contactId) {
+    // When dialed from a Person Account record, prefer associating to the corresponding Contact record
+    sfdcObjectId = response.contactId;
+    sfdcObjectType = 'Contact';
+  }
+
+  try {
+    await Actions.invokeAction('StartOutboundCall', {
+      destination: response.number,
+      taskAttributes: {
+        sfdcObjectId,
+        sfdcObjectType,
+      },
+    });
+  } catch (error: any) {
+    logger.error('[salesforce-integration] Error calling StartOutboundCall', error);
+  }
+};
+
+export const enableClickToDial = () => {
+  if (!getOpenCti()) {
+    return;
+  }
+
+  getOpenCti().enableClickToDial({
+    callback: (response: any) => {
+      if (!response.success) {
+        logger.error('[salesforce-integration] Failed to enable click-to-dial', response);
+        return;
+      }
+
+      getOpenCti().onClickToDial({
+        listener: handleClickToDial,
+      });
+    },
+  });
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/LogActivity.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/LogActivity.ts
new file mode 100644
index 000000000..5ee3e5038
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/LogActivity.ts
@@ -0,0 +1,70 @@
+import { Manager, ITask, TaskHelper } from '@twilio/flex-ui';
+
+import { getOpenCti } from './SfdcHelper';
+import AppState from '../../../types/manager/AppState';
+import { reduxNamespace } from '../../../utils/state';
+import { clearChannelNote } from '../flex-hooks/states';
+import logger from '../../../utils/logger';
+import { isCopilotNotesEnabled } from '../config';
+
+export const saveLog = (task: ITask, event: string, callback: any) => {
+  if (!getOpenCti()) {
+    return;
+  }
+
+  const { channelType } = task;
+  const channelName = channelType === 'web' ? 'chat' : channelType;
+  const isVoice = TaskHelper.isCallTask(task);
+  const { direction } = task.attributes;
+  const callType = direction === 'outbound' ? getOpenCti().CALL_TYPE.OUTBOUND : getOpenCti().CALL_TYPE.INBOUND;
+
+  const value = {
+    entityApiName: 'Task',
+    ActivityDate: task.dateUpdated,
+    CallType: callType,
+    Description: task.attributes.conversations?.content ?? '',
+    Status: 'Completed',
+    Subject: `[${event}] ${callType} ${channelName} at ${task.dateUpdated}`,
+    Type: callType,
+    CallObject: task.attributes.conference?.participants?.worker ?? '',
+    CallDisposition: task.attributes.conversations?.outcome ?? '',
+    TaskSubtype: isVoice ? 'Call' : 'Task',
+  } as any;
+
+  if (isVoice) {
+    const phone = direction === 'outbound' ? task.attributes.outbound_to : task.attributes.from;
+    if (phone) {
+      value.Phone = phone;
+    }
+  }
+
+  if (
+    !task.attributes.sfdcObjectType ||
+    task.attributes.sfdcObjectType === 'Contact' ||
+    task.attributes.sfdcObjectType === 'Lead'
+  ) {
+    value.WhoId = task.attributes.sfdcObjectId ?? '';
+  } else {
+    value.WhatId = task.attributes.sfdcObjectId ?? '';
+  }
+
+  if (isCopilotNotesEnabled()) {
+    const manager = Manager.getInstance();
+    const state = manager.store.getState() as AppState;
+    const { channelNotes } = state[reduxNamespace].salesforceIntegration;
+    const channelSid = task.conference?.source?.channel?.sid;
+
+    if (channelSid && channelNotes && channelNotes[channelSid]) {
+      // Agent copilot wrapup summary is available; use it instead
+      // Additional fields are available too (topic, sentiment)
+      logger.log('[salesforce-integration] Using agent copilot wrapup summary for call log');
+      value.CallDisposition = channelNotes[channelSid].dispositionCode.disposition_code;
+      value.Description = channelNotes[channelSid].summary;
+      manager.store.dispatch(clearChannelNote(channelSid));
+    }
+  }
+
+  logger.log('[salesforce-integration] Saving call log', value);
+
+  getOpenCti().saveLog({ value, callback });
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/ScreenPop.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/ScreenPop.ts
new file mode 100644
index 000000000..454f5bdeb
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/ScreenPop.ts
@@ -0,0 +1,82 @@
+import { Manager, ITask } from '@twilio/flex-ui';
+
+import TaskRouterService from '../../../utils/serverless/TaskRouter/TaskRouterService';
+import { getOpenCti } from './SfdcHelper';
+import logger from '../../../utils/logger';
+import { setSearchResults } from '../flex-hooks/states';
+
+export const screenPop = (task: ITask) => {
+  if (!getOpenCti() || !task) {
+    return;
+  }
+
+  if (task.attributes.direction === 'outbound') {
+    // Skip screen pop for outbound tasks as the user is likely already viewing the desired record
+    logger.log(`[salesforce-integration] Skipping screen pop for outbound task ${task.taskSid}`);
+    return;
+  }
+
+  // Handle single match record ID passed from task attributes - set via Studio flow
+  const sfdcObjectId = task.attributes.sfdcObjectId && task.attributes.sfdcObjectId.trim();
+  if (sfdcObjectId) {
+    logger.log(`[salesforce-integration] Performing screen pop of record ${sfdcObjectId} for task ${task.taskSid}`);
+    getOpenCti().screenPop({
+      type: getOpenCti().SCREENPOP_TYPE.SOBJECT,
+      params: { recordId: sfdcObjectId },
+      callback: (result: any) => {
+        if (!result.success) {
+          logger.error('[salesforce-integration] Failed to screen pop single record match', result);
+        }
+      },
+    });
+    return;
+  }
+
+  // No single match provided; perform a search and pop based on Salesforce softphone layout settings
+  const searchParams =
+    task.attributes.name || task.attributes.from || task.attributes.identity || task.attributes.customerAddress;
+
+  logger.log(
+    `[salesforce-integration] Performing search and screen pop with params "${searchParams}" for task ${task.taskSid}`,
+  );
+  getOpenCti().searchAndScreenPop({
+    searchParams,
+    defaultFieldValues: {
+      Phone: searchParams,
+    },
+    callType: getOpenCti().CALL_TYPE.INBOUND,
+    deferred: false, // We could set this true to perform processing or pop conditionally based on the result
+    callback: async (result: any) => {
+      if (!result.success) {
+        logger.error('[salesforce-integration] Failed to search and screen pop', result);
+        return;
+      }
+
+      const recordIds = Object.keys(result.returnValue);
+      if (recordIds.length === 1) {
+        // Single match; store on task for activity logging
+        try {
+          logger.log('[salesforce-integration] Saving single match record ID to task', {
+            recordId: recordIds[0],
+            taskSid: task.taskSid,
+          });
+          await TaskRouterService.updateTaskAttributes(task.taskSid, {
+            sfdcObjectId: recordIds[0],
+            sfdcObjectType: result.returnValue[recordIds[0]].RecordType,
+          });
+        } catch (error: any) {
+          logger.log('[salesforce-integration] Unable to update task', error);
+        }
+      } else if (recordIds.length > 1) {
+        // Multiple match
+        const results = Object.values(result.returnValue).map((item: any) => ({
+          id: item.Id,
+          name: item.Name ?? item.Id,
+          type: item.RecordType,
+        }));
+        Manager.getInstance().store.dispatch(setSearchResults({ reservationSid: task.sid, results }));
+        logger.log('[salesforce-integration] Multiple matches', result.returnValue);
+      }
+    },
+  });
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/SfdcHelper.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/SfdcHelper.ts
new file mode 100644
index 000000000..3d5e21aa9
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/SfdcHelper.ts
@@ -0,0 +1,17 @@
+const getSforce = () => (window as any).sforce;
+
+export const getConsole = () => getSforce()?.console;
+
+export const getOpenCti = () => getSforce()?.opencti;
+
+export const getSfdcBaseUrl = () => {
+  try {
+    return window.location.ancestorOrigins[0];
+  } catch {
+    // ancestorOrigins is not a web standard; handle non-chromium browsers here
+    return '';
+  }
+};
+
+export const isSalesforce = (baseUrl: string) =>
+  Boolean(baseUrl) && window.self !== window.top && baseUrl.includes('.lightning.force.com');
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/SfdcLoader.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/SfdcLoader.ts
new file mode 100644
index 000000000..3e12c4b66
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/SfdcLoader.ts
@@ -0,0 +1,53 @@
+import { getConsole, getOpenCti, getSfdcBaseUrl, isSalesforce } from './SfdcHelper';
+import logger from '../../../utils/logger';
+
+export const loadScript = async (url: string) =>
+  new Promise((resolve, reject) => {
+    const scriptRef = document.createElement('script');
+    const tag = document.getElementsByTagName('script')[0];
+
+    const onLoaded = (res: any) => (!res.readyState || res.readyState === 'complete') && resolve(res);
+
+    scriptRef.src = url;
+    scriptRef.type = 'text/javascript';
+    scriptRef.async = true;
+    scriptRef.onerror = reject;
+    scriptRef.onload = onLoaded;
+    (scriptRef as any).onreadystatechange = onLoaded;
+
+    tag.parentNode?.insertBefore(scriptRef, tag);
+  });
+
+export const initializeSalesforceAPIs = async () => {
+  const sfdcBaseUrl = getSfdcBaseUrl();
+
+  if (!isSalesforce(sfdcBaseUrl)) {
+    // Continue as usual
+    logger.warn(
+      '[salesforce-integration] Not initializing Salesforce APIs since this instance has been launched independently.',
+    );
+    return false;
+  }
+
+  // We only need to load Open CTI if another plugin has not done so already
+  if (!getOpenCti()) {
+    logger.log('[salesforce-integration] Loading Open CTI API...');
+    const sfOpenCTIScriptUrl = `${sfdcBaseUrl}/support/api/52.0/lightning/opencti_min.js`;
+    await loadScript(sfOpenCTIScriptUrl);
+  }
+
+  // We only need to load console APIs if another plugin has not done so already
+  if (!getConsole()) {
+    logger.log('[salesforce-integration] Loading Console Integration API...');
+    const sfConsoleAPIScriptUrl = `${sfdcBaseUrl}/support/console/52.0/integration.js`;
+    await loadScript(sfConsoleAPIScriptUrl);
+  }
+
+  if (!getOpenCti()) {
+    // We care mostly that Open CTI loaded
+    logger.error('[salesforce-integration] Salesforce APIs cannot be found');
+    return false;
+  }
+
+  return true;
+};
diff --git a/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/UtilityBarHelper.ts b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/UtilityBarHelper.ts
new file mode 100644
index 000000000..0d2780783
--- /dev/null
+++ b/plugin-flex-ts-template-v2/src/feature-library/salesforce-integration/utils/UtilityBarHelper.ts
@@ -0,0 +1,82 @@
+import { ITask, templates } from '@twilio/flex-ui';
+import { Activity } from 'types/task-router';
+
+import { getOpenCti } from './SfdcHelper';
+import logger from '../../../utils/logger';
+import { StringTemplates } from '../flex-hooks/strings';
+
+export const setSoftphonePanelVisibility = (visible: boolean) => {
+  // Check current visibility, change it if not the desired value
+  getOpenCti().isSoftphonePanelVisible({
+    callback: (response: any) => {
+      if (response.success && Boolean(response.returnValue?.visible) !== visible) {
+        getOpenCti().setSoftphonePanelVisibility({
+          visible,
+          callback: (result: any) => {
+            if (!result.success) {
+              logger.error('[salesforce-integration] Failed to set softphone panel visibility', result);
+            }
+          },
+        });
+        return;
+      }
+
+      if (!response.success) {
+        logger.error('[salesforce-integration] Failed to get softphone panel visibility', response);
+      }
+    },
+  });
+};
+
+export const setSoftphoneItemIcon = (key: string) => {
+  getOpenCti().setSoftphoneItemIcon({
+    key,
+    callback: (result: any) => {
+      if (!result.success) {
+        logger.error('[salesforce-integration] Failed to set softphone panel icon', result);
+      }
+    },
+  });
+};
+
+export const setSoftphoneItemLabel = (label: string) => {
+  getOpenCti().setSoftphoneItemLabel({
+    label,
+    callback: (result: any) => {
+      if (!result.success) {
+        logger.error('[salesforce-integration] Failed to set softphone panel icon', result);
+      }
+    },
+  });
+};
+
+export const updateUtilityBar = (activity: Activity, tasks: Map<string, ITask<Record<string, any>>>) => {
+  if (!getOpenCti()) {
+    return;
+  }
+
+  // 1. If no tasks, display the current activity
+  if (!tasks.size) {
+    setSoftphoneItemIcon(activity.available ? 'circle' : 'away');
+    setSoftphoneItemLabel(activity.name);
+    return;
+  }
+
+  // 2. Display alert for any pending tasks
+  for (const task of tasks.values()) {
+    if (task.status === 'pending' && task.attributes.direction !== 'outbound') {
+      setSoftphoneItemIcon('alert');
+      setSoftphoneItemLabel(templates[StringTemplates.IncomingTaskLabel]());
+      return;
+    }
+  }
+
+  // 3. Show task count
+  setSoftphoneItemIcon('task');
+  setSoftphoneItemLabel(
+    templates[StringTemplates.TasksLabel]({
+      numTasks: tasks.size,
+      singular: tasks.size === 1,
+    }),
+  );
+};
diff --git a/plugin-flex-ts-template-v2/src/types/feature-loader/FlexComponent.ts b/plugin-flex-ts-template-v2/src/types/feature-loader/FlexComponent.ts
index 0e49fd240..f4ea4b8be 100644
--- a/plugin-flex-ts-template-v2/src/types/feature-loader/FlexComponent.ts
+++ b/plugin-flex-ts-template-v2/src/types/feature-loader/FlexComponent.ts
@@ -19,6 +19,7 @@ export enum FlexComponent {
   QueueStats = 'QueueStats',
   SideNav = 'SideNav',
   SupervisorTaskCanvasHeader = 'SupervisorTaskCanvasHeader',
+  TaskCanvas = 'TaskCanvas',
   TaskCanvasHeader = 'TaskCanvasHeader',
   TaskCanvasTabs = 'TaskCanvasTabs',
   TaskCard = 'TaskCard',