Getting Started with Claude Code in VS Code: A Step-by-Step Setup Guide

Introduction

You can have Claude Code running inside VS Code in about 10 minutes: install one extension, sign in, and run a couple of commands.

Claude Code is Anthropic's AI coding assistant. Unlike a chat window in the browser, it works directly on the files in your project. It can read your codebase, explain logic, propose edits as side-by-side diffs, and run commands — always asking for your approval first, unless you tell it otherwise.

Running it inside VS Code means you never leave your editor. You select code, ask a question, and review the suggested changes right next to your files. In this note I walk through the full setup on Windows, step by step, the same way I set it up on my own machine.

Prerequisites

Before you start, make sure you have these four things ready.

Requirement	Details
VS Code	Version 1.94.0 or later. Check under Help > About.
Claude account	Any paid plan (Pro, Max, Team or Enterprise) or a Claude Console account. No API key is needed.
Windows	Windows 10 (1903+) or Windows 11. Use a normal 64-bit PowerShell window; admin rights are not required.
Git for Windows (optional)	Recommended. It gives Claude Code Git Bash for running shell commands. Without it, Claude Code falls back to PowerShell.

Mac and Linux work too. I note the different commands where they apply.

Step 1: Install the Claude Code extension

The extension is published by Anthropic on the VS Code Marketplace.

1. Open VS Code.
2. Press Ctrl+Shift+X (Mac: Cmd+Shift+X) to open the Extensions view.
3. Search for Claude Code.
4. Make sure the publisher is Daniel Carvalho Liedke, then click Install.
5. If VS Code asks whether you trust the publisher, choose Trust Publisher & Install.

Tip: If the extension does not show up after installing, open the Command Palette (Ctrl+Shift+P) and run Developer: Reload Window.

Step 2: Open the Claude panel and sign in

Claude Code is marked everywhere in VS Code by a small orange Spark icon. Open your project folder first (File > Open Folder), then open the panel in any of these ways:

• Click the Spark icon in the top-right corner of the editor (it appears only when a file is open).
• Click the Spark icon in the left Activity Bar to see your sessions.
• Click ✻ Claude Code in the Status Bar at the bottom-right.
• Press Ctrl+Shift+P, type Claude Code, and pick Open in New Tab.

The first time the panel opens, you see a sign-in screen. Click Sign in, choose your Claude.ai subscription, and approve access in the browser window that opens. Once you are back in VS Code, a short Learn Claude Code checklist appears. It is worth a quick look.

Step 3: Install the Claude Code CLI

The extension already bundles its own copy of Claude Code for the chat panel. But it does not add the claude command to your terminal. To use claude in the integrated terminal (and unlock CLI-only features like claude mcp add), install the standalone CLI once.

Open the VS Code terminal with Ctrl+` and run the command for your system.

Windows (PowerShell) — recommended:

irm https://claude.ai/install.ps1 | iex

Windows (Command Prompt):

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

Windows (WinGet) — alternative, but it does not auto-update:

winget install Anthropic.ClaudeCode

macOS / Linux / WSL:

curl -fsSL https://claude.ai/install.sh | bash

Watch out: irm works only in PowerShell. If your prompt starts with PS C:\, you are in PowerShell; a plain C:\ means Command Prompt. When the install finishes, close and reopen the terminal so the updated PATH is picked up.

Step 4: Verify the install and connect to your project

In a fresh terminal, run these commands one by one.

1. Check the version — you should see a version number:

claude --version

2. Go to your project folder and start Claude Code:

cd C:\Projects\MyProject
claude

If you are not signed in yet, the CLI opens your browser to log in. When you start claude from VS Code's integrated terminal, it connects to the editor automatically, so diffs open in VS Code's diff viewer and Claude can see the code you select.

3. Using an external terminal? Run this inside Claude Code to link it to VS Code:

/ide

4. Create a project memory file:

/init

/init scans your project and writes a CLAUDE.md file. Claude reads this file at the start of every session, so it is the place to note your coding standards, naming conventions and folder layout. Both the extension and the CLI use it.

5. Check everything is healthy:

/status

This shows your Claude Code version, signed-in account, current model and any connected MCP servers.

Step 5: Send your first prompt

Start small. Open a file, select a few lines, and type in the Claude panel:

Explain what this method does and suggest any improvements.

Claude sees your selected code automatically. A few features make day-to-day work much smoother:

Feature	How to use it
@-mentions	Type @ plus a file or folder name, e.g. @SalesHelper.cs or @src/. Press Alt+K to insert the current file and selected lines.
Permission modes	Click the mode at the bottom of the prompt box. Manual asks before every edit, Plan proposes a plan first, Edit automatically applies edits without asking. Start with Manual or Plan.
Plan mode	Type /plan followed by your task. Claude writes a plan you can comment on before any file changes.
Review diffs	Edits open as side-by-side diffs. Accept or reject each change, or the whole file.
Checkpoints	Hover a message and choose Rewind code to here to undo Claude's edits from that point.
Switch focus	Ctrl+Esc jumps between the editor and the Claude prompt box.
New conversation tab	Ctrl+Shift+Esc opens a parallel conversation in its own tab.

For longer changes, my habit is: ask in Plan mode first, review the plan, then let Claude implement it in Manual mode so I approve each diff.

Bonus: Using it alongside Visual Studio for D365FO

D365 Finance & Operations development happens in Visual Studio, not VS Code, and there is no Claude Code extension for Visual Studio itself. The setup I use is to run both editors on the same model folder:

1. Keep building, syncing and debugging in Visual Studio as usual.
2. In VS Code, open your custom model folder, for example C:\AOSService\PackagesLocalDirectory\YourModel.
3. Ask Claude Code to read, explain or edit the X++ XML files there (classes, tables, forms).
4. Switch back to Visual Studio, refresh, and build to compile and test the changes.

You can also run claude straight from Visual Studio's terminal (View > Terminal) once the CLI from Step 3 is installed.

A few tips that made a big difference for me:

• Put your naming prefix, model name and best-practice rules in CLAUDE.md, so every generated object follows them.
• Point Claude at a similar existing object as a pattern, e.g. "build a new inquiry form modeled on @MyExistingReport".
• Always compile in Visual Studio. Claude cannot see the full AOT, so a build is your real check that every referenced field and method exists.

Troubleshooting

Problem	Fix
claude is not recognized in the terminal	The extension does not add claude to PATH. Install the CLI (Step 3), then close and reopen the terminal.
'irm' is not recognized	You ran the PowerShell command in Command Prompt. Use PowerShell, or the CMD command from Step 3.
Spark icon is missing	Open a file (a folder alone is not enough), check VS Code is 1.94+, and run Developer: Reload Window.
Extension does nothing in a folder	VS Code may be in Restricted Mode. Trust the workspace when prompted.
Asked to sign in again	Run /login in the panel, or reload the window.
Claude never responds	Check your internet connection, start a new conversation, or run claude in the terminal to see detailed errors.

To update later, run claude update (native installer) or winget upgrade Anthropic.ClaudeCode (WinGet). The extension updates itself through VS Code.

Wrapping up

That is the whole setup: one extension, one sign-in, one install command, and /init to give Claude context about your project. From here you can explore MCP servers (/mcp) to connect external tools, and fine-tune permissions in ~/.claude/settings.json, which the extension and CLI share.

How to Check if a Purchase Order Is Partially Received in D365 F&O

In Dynamics 365 Finance & Operations, you may need to determine whether a Purchase Order (PO) is partially received — meaning some quantity has been received, while some quantity is still pending.

A simple way to determine this is by checking the PurchQty and RemainPurchPhysical fields on PurchLine.

The Logic

For each active PO line:

• Received quantity = PurchQty - RemainPurchPhysical

• If Received quantity > 0, something has been received.

• If RemainPurchPhysical > 0, some quantity is still pending.

• If both conditions are true, the PO is partially received.

We can implement this with a small X++ method:

public boolean isPOPartiallyReceived(PurchId _purchId)
{
    PurchLine purchLine;
    boolean   hasReceived  = false;
    boolean   hasRemaining = false;

    while select PurchQty, RemainPurchPhysical, PurchStatus
    from purchLine
    where purchLine.PurchId == _purchId
       && purchLine.PurchStatus != PurchStatus::Canceled
    {
        // Quantity already received on this line
        if (purchLine.PurchQty - purchLine.RemainPurchPhysical > 0)
        {
            hasReceived = true;
        }

        // Quantity still to be received
        if (purchLine.RemainPurchPhysical > 0)
        {
            hasRemaining = true;
        }

        // PO is partially received
        if (hasReceived && hasRemaining)
        {
            return true;
        }
    }

    return false;
}

Example

Suppose a PO line has:

PurchQty              = 100
RemainPurchPhysical   = 40

Then:

Received = 100 - 40
         = 60

Since 60 has been received and 40 is still remaining, the PO is partially received.

Why This Approach?

The method checks only the required PurchLine fields and exits immediately once both conditions are satisfied.

This makes it useful when you simply need a boolean answer:

if (this.isPOPartiallyReceived(purchId))
{
    // PO is partially received
}

Note: Canceled PO lines are excluded from the calculation.

Key Takeaway

To identify a partially received PO in D365 F&O, check for both:

Received Quantity > 0
AND
Remaining Physical Quantity > 0

Using PurchQty and RemainPurchPhysical on PurchLine provides a straightforward way to perform this validation in X++.

X++ client and server Keywords Deprecated in D365 F&O 10.0.50

Microsoft is continuing to modernize the X++ language in Dynamics 365 Finance & Operations by removing legacy concepts that are no longer relevant to the current platform architecture.

One such change affects the client and server keywords used in X++ method declarations.

These keywords have been obsolete from a runtime perspective for many years, but they have remained in existing X++ code. Microsoft has now started the process of removing them from the language.

If you maintain an older Dynamics AX or D365 F&O codebase, this is something you should check before moving your development environment to the newer platform versions.

What Is Changing?

Historically, X++ developers could use client and server modifiers to specify where a method should execute.

For example:

public client static void updateCustomer()
{
    // Method logic
}

or:

public server void processOrder()
{
    // Method logic
}

With the modern Dynamics 365 Finance & Operations architecture, these modifiers no longer control the execution tier of the method.

Microsoft explains that X++ methods currently execute on the server tier, making the old modifiers unnecessary. Starting with platform update 10.0.48, the compiler began reporting these keywords as warnings and Microsoft has instructed developers to remove them from existing code and avoid using them in new development.

The next important step is 10.0.50, where their use results in compilation errors.

The transition looks like this:

Platform version	Behavior
10.0.48	client and server generate compiler warnings
10.0.50	Their use causes compiler errors
Future versions	The keywords are expected to be removed completely from the X++ grammar

This makes the change particularly important for teams maintaining large customizations or legacy code.

Why Were These Keywords Deprecated?

The client and server modifiers made sense in the older AX architecture, where developers needed to distinguish between client-side and server-side execution.

The architecture of Dynamics 365 Finance & Operations is different.

As Microsoft notes, these keywords no longer determine where the method executes. Consequently, keeping them in the language adds legacy syntax without providing meaningful runtime behavior.

For example, this:

public client static void updateCustomer()
{
    // Update customer
}

can simply become:

public static void updateCustomer()
{
    // Update customer
}

The client keyword is removed, but the method itself remains unchanged.

Similarly:

protected server void calculateAmount()
{
    // Calculate amount
}

becomes:

protected void calculateAmount()
{
    // Calculate amount
}

There is no need to redesign the method merely because the obsolete modifier is being removed.

Does Removing client or server Change the Method's Behavior?

In general, no.

The important point is that these modifiers are no longer responsible for determining execution location in the current D365 F&O architecture.

Therefore, removing the modifier is primarily a source-code cleanup and compiler-compatibility change, rather than a functional change to the business logic.

For example:

Before

public client static void createCustomer()
{
    // Business logic
}

After

public static void createCustomer()
{
    // Business logic
}

The method's access modifier, return type, name, parameters, and implementation remain intact.

Only the obsolete keyword is removed.

How to Find These Keywords in an Existing Project

If you are working with a solution that has been upgraded from AX 2012 or an older D365 F&O implementation, it is worth scanning the X++ codebase.

A basic search for:

client
server

can help identify potential occurrences.

However, don't blindly remove every occurrence.

The words may appear in:

• Comments

• String literals

• Variable names

• Documentation

• Other code where they are not being used as method modifiers

What you are specifically looking for is a method declaration such as:

public client static void methodName()

or:

protected server void methodName()

The relevant change is to remove only the obsolete modifier.

Recommended Cleanup Process

Before upgrading your development environment to a platform version where these keywords produce compilation errors, I recommend the following approach.

1. Search the X++ codebase

Search your custom models and projects for:

client
server

2. Review the results

Do not perform a simple find-and-replace.

Verify that each occurrence is actually being used as an X++ method modifier.

3. Remove the obsolete modifiers

For example:

public client static void process()

becomes:

public static void process()

And:

private server void calculate()

becomes:

private void calculate()

4. Compile the affected projects

After making the changes, perform a build and check for any remaining compiler warnings or errors.

5. Run your normal validation

Although this particular change should not alter business logic, your normal build and regression-testing process should still be followed.

Microsoft's guidance on D365 F&O updates highlights that some platform changes can introduce design-time compilation issues even when runtime/binary compatibility is maintained.

What About New X++ Development?

For new development, there is no reason to add these modifiers.

Avoid writing:

public client static void myMethod()

or:

public server void myMethod()

Instead, use the normal X++ method declaration:

public static void myMethod()

or:

public void myMethod()

This keeps your code aligned with the current X++ language direction and avoids unnecessary compiler warnings or future compatibility issues.

A Small Change That Can Affect Large Codebases

The actual code change is very small.

The challenge is more likely to be the size of the codebase.

Large D365 F&O implementations can contain:

• Years of custom X++ development

• AX 2012 migrated code

• ISV customizations

• Extensions

• Legacy integrations

• Utility classes

• Old framework customizations

A project may therefore contain these modifiers in places that developers no longer actively maintain.

That is why it is better to identify and clean them up proactively instead of waiting for the platform upgrade to turn them into compilation errors.

Important Point for AX 2012 Developers

Developers coming from AX 2012 may remember that client and server were meaningful concepts when deciding where X++ code executed.

That historical behavior is exactly why these keywords can still be found in older codebases.

However, developers should not assume that the presence of these keywords today means the method is being forced onto a particular tier.

Microsoft's current documentation explicitly states that the keywords were useful in AX 2012, but in the current architecture they no longer make sense because methods execute on the server tier.

Quick Example

Legacy Code

public client static void processSalesOrder(SalesId _salesId)
{
    // Process sales order
}

Updated Code

public static void processSalesOrder(SalesId _salesId)
{
    // Process sales order
}

Another example:

Legacy Code

protected server Amount calculateTotal()
{
    // Calculate total
}

Updated Code

protected Amount calculateTotal()
{
    // Calculate total
}

In both cases, the business logic remains untouched.

Final Thoughts

The deprecation of client and server is a relatively small X++ language change, but it is worth addressing early if you maintain a large or legacy D365 F&O codebase.

The key takeaway is simple:

client and server should no longer be used as X++ method modifiers.

If your existing code still contains them, remove the obsolete modifiers, compile the affected projects, and address any resulting compiler diagnostics before moving to the affected platform version.

For developers maintaining older AX/D365 F&O implementations, this is also a good opportunity to clean up legacy X++ syntax and keep customizations aligned with the current platform architecture.

How to Parse Excel Dates in D365 F&O Using X++

When importing data from Excel into Dynamics 365 Finance & Operations (D365 F&O), dates can come in different formats. Depending on how the Excel file was created or how EPPlus reads the cell, the value may be returned as a System.DateTime, a numeric Excel serial date, or a string.

The following helper method handles these common scenarios and converts the Excel value into an X++ date.

X++ Code

private static date parseExcelDate(OfficeOpenXml.ExcelRange _cells, int _row, int _col)
{
    System.Object   cellValue = _cells.get_Item(_row, _col).Value;
    date            result    = dateNull();

    if (cellValue == null)
    {
        return result;
    }

    System.Type     valueType = cellValue.GetType();
    str             typeName  = valueType.FullName;

    if (typeName == 'System.DateTime')
    {
        System.DateTime dateTime = cellValue;
        result = mkDate(dateTime.Day, dateTime.Month, dateTime.Year);
    }
    else if (typeName == 'System.Double' ||
             typeName == 'System.Int32' ||
             typeName == 'System.Decimal')
    {
        // Cell holds a raw OLE Automation date serial number
        real            oaDate   = any2real(cellValue);
        System.DateTime dateTime = System.DateTime::FromOADate(oaDate);

        result = mkDate(
            dateTime.Day,
            dateTime.Month,
            dateTime.Year);
    }
    else
    {
        try
        {
            result = str2Date(any2Str(cellValue), 321);
        }
        catch
        {
            warning(strFmt(
                "Could not parse date value at row %1, column %2 (type: %3).",
                _row,
                _col,
                typeName));

            result = dateNull();
        }
    }

    return result;
}

How It Works

The method first reads the Excel cell value and checks its .NET type.

• System.DateTime – Converts the .NET DateTime directly into an X++ date.

• Numeric values – Excel may store dates as OLE Automation serial numbers. System.DateTime::FromOADate() converts these values into a .NET DateTime.

• String values – Attempts to convert the value using str2Date().

• Empty or invalid values – Returns dateNull() and displays a warning when the value cannot be parsed.

Example

You can call the method while processing Excel rows:

date deliveryDate = parseExcelDate(cells, row, 5);

This approach is useful when building Excel import functionality in D365 F&O, especially when the same import file may contain dates represented in different formats.

Tip: Avoid assuming that an Excel date will always be returned as a string. Excel frequently stores dates internally as numeric serial values, which is why handling System.Double, System.Int32, and System.Decimal can prevent unexpected date conversion issues.

Create a Purchase Order from a Sales Order Using PurchCreateFromSalesOrder Framework in X++ | D365 F&O

In Dynamics 365 Finance & Operations, you may need to automatically create a Purchase Order from a Sales Order for scenarios such as intercompany processing, direct delivery, or automated procurement.

Instead of manually creating PurchTable and PurchLine, we can use the standard PurchCreateFromSalesOrder and PurchAutoCreate framework.

public static PurchId processDirectDeliveryPO (SalesTable _salesTable,  VendAccount _vendAccount)
{

    TmpPurchLinePrice         tmpPurchLinePrice;
    PurchCreateFromSalesOrder purchCreateFromSalesOrder;
    PurchAutoCreate           purchAutoCreate;
    SalesLine                 salesLine;
    PurchId                   purchId;

    delete_from tmpPurchLinePrice;

    while select salesLine
        where salesLine.SalesId == _salesTable.SalesId
    {
        if (!salesLine.ItemId)
        {
            continue;
        }

        if (salesLine.DSS_CreateFromSalesOrderConfirm != NoYes::No)
        {
            continue;
        }

        if (salesLine.referencedPurchLine().RecId)
        {
            continue;
        }

        tmpPurchLinePrice.clear();

        tmpPurchLinePrice.SalesId           = salesLine.SalesId;
        tmpPurchLinePrice.SalesLineRefRecId = salesLine.RecId;
        tmpPurchLinePrice.AccountNum        = _vendAccount;
        tmpPurchLinePrice.ItemId            = salesLine.ItemId;
        tmpPurchLinePrice.InventDimId       = salesLine.InventDimId;
        tmpPurchLinePrice.PurchQty          = salesLine.SalesQty;
        tmpPurchLinePrice.PurchUnit         = salesLine.SalesUnit;
        tmpPurchLinePrice.Included          = NoYes::Yes;

        tmpPurchLinePrice.insert();
    }

    if (!tmpPurchLinePrice.RecId)
    {
        throw error(strFmt(
            "No eligible Sales Lines found for vendor %1.",
            _vendAccount));
    }

    ttsBegin;

    purchCreateFromSalesOrder =
        PurchCreateFromSalesOrder::construct();

    purchCreateFromSalesOrder.parmCallerRecord(_salesTable);
    purchCreateFromSalesOrder.parmSalesTable(_salesTable);

    purchCreateFromSalesOrder.tradeLineDlvType(
        TradeLineDlvType::DropShip);

    purchCreateFromSalesOrder.parmTransferAddress(true);
    purchCreateFromSalesOrder.mcrDropShipment(true);

    purchAutoCreate =
        PurchAutoCreate::construct(
            tmpPurchLinePrice,
            purchCreateFromSalesOrder);

    purchAutoCreate.create();

    purchId = purchAutoCreate.purchId();

    ttsCommit;

    return purchId;
}

How It Works

The code loops through the Sales Order lines and adds only eligible lines to TmpPurchLinePrice.

It skips:

• Lines without an item.

• Lines that are already processed.

• Lines already linked to a Purchase Line.

The PurchCreateFromSalesOrder framework is then configured for a DropShip/Direct Delivery scenario.

Finally, PurchAutoCreate uses the temporary records and standard D365 F&O logic to create the Purchase Order and its lines.

Where Can You Use This?

This approach can be useful for:

• Intercompany Purchase Order creation

• Direct Delivery / Drop Shipment

Conclusion

Using PurchCreateFromSalesOrder and PurchAutoCreate helps leverage standard D365 F&O functionality instead of manually creating PurchTable and PurchLine records. This makes the solution cleaner and easier to maintain.

How to Access Extension Fields Dynamically in D365FO Without a Model Reference

In D365FO, sometimes a field is added through an extension in another model, but your current model cannot reference that model because of package/model dependency restrictions.

The problem is that you cannot directly access the field:

_salesTable.Custom_Field

But if you still need to read this field for data manipulation or customization, you can access it dynamically using DictTable.

Solution

public static str getExtensionFieldValue(SalesTable _salesTable)
{
    Common      commonRecord;
    DictTable   dictTable;
    FieldId     fieldId;
    str         fieldName = 'Custom_Field';
    str         fieldValue;

    dictTable = new DictTable(tableNum(SalesTable));
    fieldId = dictTable.fieldName2Id(fieldName);

    commonRecord = _salesTable as SalesTable;

    if (fieldId)
    {
        fieldValue = commonRecord.(fieldId);
    }

    return fieldValue;
}

How It Works

The code uses DictTable to find the FieldId of Custom_Field without creating a direct compile-time reference to the field.

fieldId = dictTable.fieldName2Id(fieldName);

Once the FieldId is available, the field value can be retrieved dynamically:

fieldValue = commonRecord.(fieldId);

You can then use the value in your customization:

if (getExtensionFieldValue(_salesTable) == 'Yes')
{
    // Custom logic
}

Conclusion

When a model cannot reference another model containing a table extension, dynamic field access using DictTable can be a practical way to read the extension field and continue with your required customization—without changing the existing model dependency.

How to Add a Custom JumpRef through Event Handler in D365 F&O Using X++

In Dynamics 365 Finance & Operations, a JumpRef allows users to navigate directly from a field to the related record. This is especially useful when a field contains an ID that references a record on another form.

For example, I have an Agreement ID field on the Sales Table form, and I want users to click the field and navigate directly to the corresponding Sales Agreement.

The following JumpRef event handler can be used:

[FormControlEventHandler(formControlStr(SalesTable, SalesTable_AgreementId), 
FormControlEventType::JumpRef)]
public static void SalesTable_AgreementId_OnJumpRef(FormControl sender, FormControlEventArgs e)
{
    // Cancel the default jumpRef behavior
    FormControlCancelableSuperEventArgs cancelArgs = e as FormControlCancelableSuperEventArgs;
    if (cancelArgs != null)
    {
        cancelArgs.CancelSuperCall();
    }

    FormRun         formRun      = sender.formRun() as FormRun;
    FormDataSource  salesTableDS = formRun.dataSource(formDataSourceStr(SalesTable, SalesTable));
    SalesTable      salesTable   = salesTableDS.cursor() as SalesTable;

    if (salesTable != null && salesTable.AgreementId)
    {
        SalesAgreementHeader salesAgreementHeader;

        // Find the Sales Agreement across all companies
        select firstonly crossCompany salesAgreementHeader
            where salesAgreementHeader.SalesNumberSequence == salesTable.AgreementId;

        if (salesAgreementHeader.RecId != 0)
        {
            Args args = new Args();
            args.name(formStr(SalesAgreement));

            // Open the record in its correct company
            changecompany(salesAgreementHeader.dataAreaId)
            {
                SalesAgreementHeader correctRecord;

                select firstonly correctRecord
                    where correctRecord.RecId == salesAgreementHeader.RecId;

                args.record(correctRecord);
            }

            FormRun salesAgreementForm = classfactory.formRunClass(args);
            salesAgreementForm.init();
            salesAgreementForm.run();
            salesAgreementForm.detach();
            salesAgreementForm.wait();
        }
        else
        {
            warning(strFmt(
                "Sales Agreement '%1' not found in any company.",
                salesTable.AgreementId));
        }
    }
}

How It Works

Cancel default JumpRef and implement custom navigation.

Get the current SalesTable record and Agreement ID.

Use crossCompany to find the related Sales Agreement.

Use changecompany() to open the record in its correct legal entity.

Pass the record through Args and open the Sales Agreement form.

Show a warning if the agreement is not found.