Have you automated Word document generation but still need someone to sign each document manually? This extra step can slow down approvals, create multiple document versions, and make it harder to track signed files.

What if you could handle the entire process directly in your application?

The Syncfusion® .NET Word Library introduces digital signature support in Essential Studio 2026 Volume 3. You can now sign, validate, and manage digital signatures in Word documents using C#, without depending on Microsoft Word or Office Interop.

With digital signatures built into your document process, you can handle document generation, signing, validation, and delivery in one automated process.

In this blog, you’ll learn how to:

• Add invisible digital signatures to Word documents.
• Create and sign visible signature lines.
• Validate signed DOCX files.
• Remove signatures before making document changes.
• Apply supported XML digital signature standards.
• Manage multiple signature lines in a document.

Why automate digital signatures in Word documents?

Signing a few documents manually may not be a problem. But what happens when your application generates hundreds of offer letters, contracts, or approval documents every day? Managing all those signatures manually can quickly become difficult.

Automating digital signatures helps applications:

• Reduce manual approval steps.
• Avoid unnecessary document copies.
• Maintain document integrity.
• Validate signatures before sharing documents.
• Improve document tracking and auditability.
• Simplify approval processes.

Consider an HR application that automatically generates offer letters. Without automation, HR teams need to download each document, sign it, upload the signed copy, and keep track of different versions.

With digital signature automation, the application can sign documents, validate them, and store the approved versions directly within the approval process.

Here’s how the manual and automated approaches compare:

How to automate digital signatures in Word documents using C#

Let’s see how to add digital signatures to Word documents using the Syncfusion .NET Word Library (DocIO).

We’ll walk through loading a document and signing certificate, creating invisible and visible signatures, validating signed documents, and managing document revisions.

Step 1: Install the required NuGet package

First, install the Syncfusion.DocIO.Net.Core NuGet package in your .NET application.

Run the following command in the Package Manager Console:

Install-Package Syncfusion.DocIO.Net.Core

Next, import the required namespaces:

using Syncfusion.DocIO;
using Syncfusion.DocIO.DLS;
using Syncfusion.Office;
using System;
using System.IO;

These namespaces provide the classes required to load Word documents, configure digital signatures, work with certificates, and save signed files.

Step 2: Load the document and signing certificate

Before adding a digital signature, you need two things:

1. The Word document you want to sign.
2. A digital certificate containing the signer’s private key.

The certificate is typically provided as a password-protected .pfx or .p12 file.

You can load the DOCX document using the WordDocument class and the signing certificate using OfficeDigitalSignatureCertificate.

using WordDocument document = new WordDocument(
    "input.docx", FormatType.Docx);

OfficeDigitalSignatureCertificate certificate =
    new OfficeDigitalSignatureCertificate(
        "PrivateKey.pfx", "certificate-password");

Also, make sure the certificate is valid, contains the required private key, and has not expired.

Step 3: Add an invisible digital signature to a Word document

Not every document needs a visible signature block. Sometimes, you simply want to confirm who signed the document and whether its content has changed since signing.

That’s where invisible digital signatures help. They protect the document without adding a visible signature area to the page.

With DocIO, you can use the AddDigitalSignature() method to sign a Word document using the loaded certificate.

You can configure the SignatureSettings class to specify details such as the signing time and comments.

SignatureSettings settings = new SignatureSettings
{
    SignTime = DateTime.Now,
    Comments = "Approved"
};

document.AddDigitalSignature(certificate, settings);
document.Save("DigitallySigned.docx", FormatType.Docx);

Here, SignTime specifies the signing time, while Comments stores additional information associated with the signature.

Once the signature is added, save the document in DOCX format.

The resulting document contains an invisible digital signature that can be validated later.

Step 4: Add a visible digital signature to a Word document

Some business documents need a visible approval area so readers can easily identify where a document was signed.

You may see these signature lines in:

• Contracts and legal agreements.
• Employees offer letters.
• Procurement approvals.
• Financial authorization documents.
• Business agreements.

DocIO allows you to create a signature line with signer details and a unique identifier. You can then use this identifier when applying the digital signature through SignatureSettings.

First, create a signature line in the Word document and retrieve its unique ID. The signatureLineId in the following example represents that ID.

You can also provide a signature image to give the signature line a familiar handwritten-signature appearance.

byte[] SignatureLineImage = File.ReadAllBytes("signature.png");

SignatureSettings visibleSettings = new SignatureSettings
{
    SignatureLineId = signatureLineId,
    SignatureLineImage = SignatureLineImage,
    SignTime = DateTime.Now,
    Comments = "Reviewed and approved"
};

document.AddDigitalSignature(certificate, visibleSettings);

document.Save(
    "VisibleDigitalSignature.docx", FormatType.Docx);

Here:

• SignatureLineId identifies the signature line to be signed.
• SignatureLineImage specifies the image displayed in the signature area.
• SignTime records the signing time.
• Comments adds information associated with the signature.

The signatureLineId must match the unique ID of a signature line already created in the document.

Step 5: Validate digital signatures before sharing documents

Adding a digital signature is only one part of the process. You should also check whether the signature is still valid before sharing, distributing, or archiving the document.

For example, an enterprise document management system can validate a signed DOCX file before moving it into permanent storage.

DocIO provides the DigitalSignatures collection to access the signatures in a Word document.

You can check whether a document contains signatures and whether those signatures are valid using the following properties:

• DigitalSignatures.Count: Gets the number of signatures in the document.
• DigitalSignatures.IsValid: Checks whether all signatures in the collection are valid.
• signature.IsValid: Checks an individual signature.

You can also retrieve details such as signing time and signature comments.

Here’s how to check the signatures in a document:

using WordDocument signedDocument = new WordDocument(
    "DigitallySigned.docx", FormatType.Docx);

bool hasSignatures = signedDocument.DigitalSignatures.Count > 0;

bool allSignaturesValid =
    signedDocument.DigitalSignatures.IsValid;

foreach (var signature in signedDocument.DigitalSignatures)
{
    bool isValid = signature.IsValid;
    string comments = signature.Comments;
    DateTime signingTime = signature.SigningTime;
}

This example checks whether the document contains signatures and whether they are valid. It also retrieves the validation status, comments, and signing time of each signature.

For example, before sending an approved contract to a customer, your application can validate its signatures and proceed based on the validation result.

Try the validation demo to verify signed documents and explore additional validation scenarios.

Step 6: Choose the right digital signature standard

Different applications may have different digital signature requirements. Some may need standard XML digital signatures, while others may require additional signature policy information.

DocIO allows you to specify the required signature standard using the XmlDsigLevel property in SignatureSettings.

It supports the following standards:

XmlDSig

XML Digital Signature (XMLDSig) is the standard W3C format for digitally signing XML content. It is suitable for standard document-signing scenarios.

XAdES-EPES

XAdES-EPES extends XML digital signatures with explicit signature policy information. This allows applications to associate a signature with a defined signing policy.

Things to consider when choosing a standard:

• Check your organization’s digital signature requirements.
• Select a standard that aligns with the applicable signing policy.
• Make sure the systems that receive and validate your documents support the selected standard.
• Verify any additional compliance requirements separately.

You can configure the required standard using the XmlDsigLevel enumeration. Here’s an example of configuring both standards:

SignatureSettings xmlSettings = new SignatureSettings
{
    XmlDsigLevel = XmlDsigLevel.XmlDSig,
    SignTime = DateTime.Now
};

document.AddDigitalSignature(certificate, xmlSettings);

SignatureSettings xadesSettings = new SignatureSettings
{
    XmlDsigLevel = XmlDsigLevel.XAdEsEpes,
    SignTime = DateTime.Now
};

document.AddDigitalSignature(certificate, xadesSettings);

Choose the appropriate standard based on your application’s requirements. Selecting a signature standard alone does not guarantee regulatory compliance; your complete signing process must meet the applicable certificate and policy requirements.

Step 7: Remove digital signatures before updating a document

Need to update a document after it has been signed? You should remove the existing signatures before making changes. Otherwise, the signatures may no longer be valid.

Consider a contract amendment. Once a contract has been signed, the business may need to update a clause or change an agreement date. The previous signature no longer represents the updated document.

With DocIO, you can use the RemoveAllDigitalSignatures() method to remove all digital signatures from a document.

Here’s how to do it:

using WordDocument signedDocument = new WordDocument(
    "DigitallySigned.docx", FormatType.Docx);

signedDocument.RemoveAllDigitalSignatures();

signedDocument.Save(
    "UnsignedForRevision.docx", FormatType.Docx);

A good approach is to follow these steps:

1. Preserve the original signed document.
2. Create a separate working copy.
3. Remove signatures from the working copy.
4. Make the required document changes.
5. Apply new digital signatures after the changes are complete.

Keeping separate signed and unsigned copies helps maintain a clear document history and makes it easier to track revisions.

Learn more about removing signatures before revising document content.

Step 8: Manage multiple signature lines in a document

What if a document needs approval from more than one person?

For example, a procurement agreement may need signatures from a department manager, finance manager, and authorized approver.

DocIO allows you to insert multiple signature lines into a Word document and sign each line individually.

You can create separate signature lines using the AppendSignatureLine() method. Each line has its own unique identifier, which you can retrieve and associate with the corresponding signer.

When signing, pass the appropriate identifier through the SignatureSettings.SignatureLineId property.

You can then apply the digital signature to each signature line and save the signed document.

This is useful for applications that need multiple approval sections in the same document.

Common scenarios for digital signature automation

Digital signature automation can be useful in several types of applications.

Here are a few examples:

• HR applications: Automatically sign employees offer letters, appointment letters, and other employment documents.
• Contract management systems: Sign agreements and validate them before sharing with customers or partners.
• Procurement applications: Manage purchase agreements and approval documents.
• Financial applications: Sign financial reports and authorization documents.
• Document management systems: Validate signed documents before storing or archiving them.

In each scenario, automating digital signatures helps reduce manual work while keeping document signing and validation within the application.

Discover the user-friendly features of the Syncfusion Word Library, reshaping your document creation process with ease.

Try It Free

Keep document signing within your application

Why handle document signing manually when you can automate it directly in your .NET application?

With the Syncfusion .NET Word Library, you can add invisible digital signatures, create visible signature lines, validate signed documents, and manage document revisions using C#.

Whether you’re building an HR application, contract management system, or enterprise document process, these capabilities help reduce manual steps while maintaining document integrity and auditability.

Ready to try it in your application? Explore the digital signature documentation and download the GitHub samples to see the complete implementation.

This feature is available in the Essential Studio 2026 Volume 3 release. You can also explore the Release Notes and What’s New pages for additional updates.

Existing customers can access the latest version through the License and Downloads page. New users can start a 30-day free trial and explore the capabilities of the Syncfusion .NET Word Library.

If you have questions or feedback, reach out through our support forums, support portal, or feedback portal. We’re happy to help!

PostgreSQL’s biggest technical advantage is its extensibility. Extensions like PostGIS, TimescaleDB, and pg_stat_statements let you reshape the database for time-series data, geospatial queries, performance monitoring, and more.

However, critics often push back with fear, uncertainty, and doubt (FUD) – extensions are hard to maintain, get abandoned, aren’t supported in the cloud… Those claims contain some truth, but are mostly overstated. Here’s why.

What is FUD?

There’s a phrase I’ve been using for a long, long time (have I said lately that I’m old?)

That phrase is fear, uncertainty and doubt (FUD).

I always thought that it had it’s start somewhere in politics. However, a quick search finds that it has two beginnings. The first was in the 1920s when it was coined as a sales tactic, but it kind of fell out of favor.

Then, in 1975, Gene Amdahl – working to create a competitor to IBM – brought it back to life, funnily enough by talking about the IBM sales reps. I guess the phrase fell out of favor, but not the sales concept.

Basically, it’s a way to cast something in a bad light. That way, the thing you want, or the path you’re hoping to go down, looks better by comparison. Honestly, though, it’s just a tad evil in my opinion.

Why (and how) does FUD target PostgreSQL extensions?

As a big proponent of PostgreSQL, the number one technical reason (again, in my opinion) to use PostgreSQL is the inherent, engineered-from-the beginning extensibility of the tool.

Need to work with time-series data? There’s a specific extension, TimeScaleDB, that turns PostgreSQL into the time-series king.

Want to have a way to query performance metrics, similar to the DMVs in SQL Server? Great, you can use pg_stat_statements for that.

There are simply hundreds of these – from little tiny functions to huge, new, wildly-effective capabilities that completely change what PostgreSQL can do.

Yet, I hear all the time (especially while talking to people who are dedicated to their old platforms):

“Well, sure. You can use an extension, but did you know:
A) They have to be maintained, upgraded, and possibly administered, independently of PostgreSQL itself.
B) You’re dependent on a team or individual to keep them up to date and they get abandoned.
C) Cloud providers don’t support a lot of extensions.”

I mean, yikes. You really want that kind of headache in your production database?”

Well, while all three statements have some truth to them, this is very much FUD. Let me explain why.

Do PostgreSQL extensions require independent maintenance?

I intend to be fair, open and honest in this conversation. It’s 100% true that extensions will have to be maintained. For that maintenance, in this discussion, I’ll focus primarily on keeping them updated.

Yes, there’s potentially other things you have to worry about as well (depending on the extension), but versioning and upgrades are two of the biggest issues that the FUD people bring up.

How extension upgrades work across databases and clusters in PostgreSQL

Extensions are upgraded entirely independently from your PostgreSQL cluster.

The code required to run an extension has to be added to your cluster, with each extension then ‘installed’ to a database – and they are database-specific.

A practical example of how extension upgrades work across databases and clusters in PostgreSQL

To understand this further, let’s say – for example – you have two databases on your cluster. On one, you want to create and maintain geographical data. This means you’re taking advantage of PostGIS (or a number of other extensions, depending on your needs.)

The other one, meanwhile, is an OLAP (online analytical processing) database – so you add pgColumnar (or Citus Columnar, or pg_mooncake, or…) to enable the use of columnstore tables and indexes. Cool, right?

Yes, but let’s now pick on pgColumnar in a completely fictitious way (and please let me emphasize: what I’m about to say isn’t true)…

In this completely fake scenario, the people maintaining pgColumnar are informed that there’s a security hole in the product. They immediately get on it and supply an update. That’s great. However, you, my friend, had best be monitoring which extensions you’re using – and keeping an eye on them for just this kind of update.

That’s because there’s currently no mechanism in PostgreSQL that will find and install these updates for you (outside of any third-part extension that may or may not have been created for this).

What this means is simple: you could have a security vulnerability that you don’t know about.

Further, let’s say you’re on PostgreSQL 15. You decide that now’s the time to upgrade to PostgreSQL 19 or a later version, depending on when you’re reading this.

In addition to all the processing, testing, and planning required to move from 15 to 19, you’ll need to determine which version of all your extensions is supported by 19. That’s for every database, on every cluster, for every extension.

See, a ton of work. “PostgreSQL extensions are horrible. No need to ever leave MySQL…”

Why this overhead isn’t unique to extensions

Ah, come on! We’ve always had this problem. It’s not new. Don’t believe me? OK. Let me ask, how are you backing up your enterprise systems? Most likely with a third-party tool or a custom set of functions, right?

And do you have to maintain those independently of your database?

Yes, you do.

How about the OS? Need to maintain that independently of the database? Again, yes.

Security tools? Compliance? Deployment? Virus detection? I could keep going, but you get the point.

Does this add some overhead and, let’s be honest, risk to our database clusters? Yes, it does. However, no more than all the other things I listed (and a million more).

We work in a complex, ever-changing environment. Extensions are not the thing that broke the camel’s back – especially true when you consider that the extensions make your camel rocket-powered.

Any addition to overhead is absolutely worth the price. We just need to know that going in.

Are PostgreSQL extensions at risk of being abandoned?

Is it possible for an extension to simply be abandoned, no longer under development, completely and utterly unsupported? Yes, it is.

The overriding majority of extensions are created and maintained exactly the same way as PostgreSQL itself: through open-source development and distribution. The single largest concern around open-source is a lack of dedicated support and liability.

Open-source projects get abandoned at a pretty high rate. Accurate numbers are tough to come by, but the shorter-lived the project, or the more niche and small it is, the higher that rate goes. Anyone saying this is not a problem is probably trying to sell you something.

After all, one of the largest and most popular extensions, pgBackRest, was nearly abandoned just recently.

The pgBackRest near-abandonment, explained

CrunchyData, who had supported the project for 13 years, were purchased by Snowflake, who didn’t want to continue that support.

The result? Fast forward just a few days, and a nine-company coalition was formed to save it.

On another note, when was the last time you used Skype? Or played any games on Flash? Or, to get more obscure (and expensive), remember the time the US government spent about $500 million on an eight-year project that is still three years from completion (in theory) and has cost several billion dollars?

The point is, commercial and closed-source software seem to suffer more than their share of abandonment as well. It’s not just a curse assigned to open-source.

Why open-source can recover where closed-source can’t

I like to bring up the pgBackRest story because it illustrates the most important part of this question. If an extension is used widely, is it likely to be abandoned? The answer is absolutely not.

When pgBackRest hit the wall, there were immediately plans being made to fork the code or find other sources of support. The latter succeeded fast enough that the former wasn’t necessary, but therein lies the power of open source: had it been necessary, we could have forked the code and kept it going.

Another great example of this is the Hudson software project run by Sun. After Oracle purchased them, a fork was made of Hudson in 2009. That’s Jenkins, and it’s still going strong today.

While this is a risk, again, it’s no different than risks we already run with both open-source and commercial software.

Which PostgreSQL extensions are supported in the cloud?

Can you run your ‘vital-to-the-business’ extension in the cloud? Well…let’s narrow this down a little more.

PaaS vs. VM vs. SBaaS: why support varies

Here, just saying ‘cloud’ is simply not adequate because, for example, the cloud includes Virtual Machines (VM). Can you run your extension on a VM?

Well, yes – you’re probably running it on a VM now, locally.

What we mean when we say ‘cloud’, however, is more the platform-as-a-service (PaaS) offerings of EnterpriseDB, Google, Azure, and AWS. (And, over on the database-as-a-service (DBaaS) side, we’re limited in what extensions we can actually run.)

All the various PaaS offerings are forks of PostgreSQL, many (most?) of which have split compute and storage in order to optimize them. Further, each cloud platform is radically different under the covers than your local implementation of Linux Mint – regardless of what operating systems, VMs or containers they’re using to work their magic.

They’ve also built out all sorts of hardware and networking in order to supply the functionality that their PaaS offers.

Combine all of that, and an extension that fundamentally requires access to the underlying OS and storage engine (like TimeScale) simply can’t be added.*

Of course, Tiger Data does have a fork of their own for PostgreSQL, with which you can pay to run TimeScale on the cloud vendor of your choice.

The answer here is honestly more complex. In this case, it has nothing to do with the popularity or support of the extension. As stated, it’s dependent on how the cloud vendor’s systems operate. That alone may or may not limit your ability to put your PostgreSQL on the cloud.

However, as established, there are alternatives. You can always revert back to running a VM or use a service like Tiger Cloud.

What extensions are supported across all major cloud vendors?

Of the roughly 575 extensions listed on the PostgreSQL Extension Encyclopedia (Pigsty, *snicker*), only around 15% have cloud vendor support.

(I’m using AI to generate these counts, so take it as you will).

On that 15%, the extensions supported by all the major cloud vendors include:

These are some of the most widely-used extensions out there – so yes, there are certainly limits on the cloud, but this is again more about FUD than anything else.

Further, many of the cloud providers have proprietary extensions they’ve created to enhance your experience.

EnterpriseDB has a bunch of extensions around providing a mechanism for running Oracle workloads on PostgreSQL databases.

AWS has Babelfish to turn your database code into something PostgreSQL understands.

And Azure created QueryStore in PostgreSQL to provide better monitoring than the native offering.

So, even on the cloud, extensions are one of the reasons why PostgreSQL is so popular.

*An exception is Microsoft Flexible Server. That supports the open-source version – not the enterprise extension – to a DBaaS offering.

The verdict: is PostgreSQL extension FUD justified?

I’m not saying that everything is all sunshine and rainbows when it comes to PostgreSQL. When extensions are added – as they often are – the platform becomes more of a beast to manage.

Yet, the mechanisms and methodologies used for this management are nothing new. Sure, open-source projects can be abandoned, exactly the same as commercial ones. But they can also be reborn, and can live on in multiple ways.

While the limitations of extensions within the cloud are also quite real, they’re usually not in places likely to hurt you, since most of the popular extensions are supported by the cloud providers.

Extensions are one of the best technical reasons to use PostgreSQL. They’re not as scary as you may have been led to believe. Don’t buy into the FUD!

The post PostgreSQL extensions: why the FUD is wrong appeared first on Simple Talk.

2026-11-13

• Add regular expression support to enterprise-managed Shell, Bash, and PowerShell permission rules
• Add --host-allow-session-creation to let remote clients create sessions on CLI hosts for one launch without changing saved settings
• Refresh /usage premium request usage so percentages stay current.
• Prevent duplicate MCP OAuth reconnects and keep servers in needs-auth after canceled authorization
• Markdown tables containing a wide symbol followed by the text variation selector, such as ⌛︎, render with correctly aligned rows
• The footer.showCodeChanges setting description now says it shows the lines added and removed by Copilot's file edits in this session, not pending changes
• The /usage activity graph now fits narrow terminals by showing fewer weeks, instead of wrapping every day row in two
• Shell output and custom status lines display correctly when terminal control sequences appear, without applying unintended text styles
• /rewind with Conversation + files no longer counts, lists or reports as restored a file that later turns had already put back or deleted again
• Interactive /plugin marketplace commands find repository-local marketplaces when the CLI starts in a subdirectory
• Keep selection labels readable and rows aligned in /environments when using --screen-reader
• /skills get without a skill name and the /mcp usage text name the get and remove verbs instead of the retired info and delete
• /diff shows a clear notice for binary files instead of garbled text or an empty pane
• The /usage activity graph hides its legend in narrow panes to prevent it from wrapping onto extra lines
• The $ shell shortcut reports launch failures once with a clear reason, including when Ctrl+G opens the editor at the same time.
• /mcp search installs registry servers with URL variables using the values you enter
• Custom status lines render terminal colors and formatting correctly, without stray characters after color resets.
• Hook approval dialogs show control characters in tool names and arguments as visible text instead of hiding or restyling them
• /session delete-all, /session prune, and /session delete preserve sessions running in the background in the same window
• Text that fits on one row stays on one row after resizing the terminal
• In /workflows, a run's Agents list no longer runs off the bottom of a short terminal: the selected agent stays on screen, and a long phase title stays on one row
• copilot plugin enable, disable, update and uninstall now fail and name config.json when it cannot be parsed, instead of reporting success without a change or that the plugin is not installed
• --no-color preserves text styling while disabling colors, even when FORCE_COLOR is set
• Pasted image paths attach correctly when you press Enter immediately after pasting in terminals that mark pasted input
• Keep the selected /share action visible when navigation keys cannot move the selection in short terminals
• MCP forms show validation errors immediately for answers edited in an external editor with Ctrl+G
• Running copilot --continue with no previous session shows the welcome header and Getting started box.
• Keep the Sessions tab responsive when dialogs open during navigation, and show pending dialogs where they can be answered
• Keep the highlighted confirmation option visible in the Sessions tab and /environments on short terminals
• Keep the /theme picker's title and border on screen in narrow terminals and beside the docked Sessions sidebar, dropping the preview instead
• The /share screen keeps the selected action visible in narrow terminals
• /ask and /btw show answers correctly beside the Sessions sidebar in narrow terminals
• Keep the /tasks title and borders visible when the task list is longer than the terminal can display
• copilot -p "/compact" --silent no longer prints the compaction result line to stdout, so --silent output stays limited to the agent's response
• Keep the prompt, tab bar, and status line visible when typing a multi-line draft during the startup animation on short terminals
• /diff shows staged renames under their new names, including edits made while renaming
• With experimental dynamic workflows, a workflow's own agent can no longer start or resume workflow runs, so a workflow can no longer start copies of itself without limit when all tools are allowed.
• With the high-contrast theme on a 16 or 256-colour terminal, the Sessions tab shows the status icon of the selected row instead of drawing it blue on blue
• Follow-ups typed while the agent is working now run in the order they were typed; one that reached the session between two turns is no longer overtaken by follow-ups typed after it.
• The /usage activity graph counts only the prompts you typed, not sub-agent or autopilot prompts, and its message total matches the days the graph draws
• Pasted escape sequences no longer change text colours or hide text in search fields
• copilot -p with --trust-folder, run from a subdirectory of a repository, now warns that the hooks at the repository root were not loaded and says how to load them
• Custom status lines display non-ASCII characters correctly even when commands write them in pieces
• Copying inline code from wrapped rows after resizing the terminal no longer includes extra non-breaking spaces.
• Queued slash commands now show an error when they fail instead of disappearing silently
• Prompts sent as a turn finishes now run without waiting for background agents to complete
• Dragging the sessions divider or scrollbar now ends cleanly when the left mouse button is no longer held.
• Allow your own scratch files under /tmp on macOS without path permission prompts unless --disallow-temp-dir is set
• Re-attaching an image or document after switching models or compacting a session sends its content to the model
• Show an error when /update cannot download a release instead of leaving the download progress message indefinitely
• Sessions started with /new or from the Sessions tab can be controlled from GitHub when remote sessions are enabled
• Expand ${COPILOT_PLUGIN_ROOT} in plugin hook working directories and environment values
• Push-to-talk preserves dictated text when held Space key repeats pause and resume
• OAuth sign-in for remote MCP servers works through proxies that require Kerberos (Negotiate) authentication
• Show permission prompts, questions, and confirmations directly in the sub-agent view so you can respond without leaving it
• Keep text after terminal control sequences visible in labels and output, and hide embedded image data
• Search in /skills, /mcp, and /plugin matches visible text instead of words hidden inside terminal escape sequences
• Clear the previous profile's routed model from the footer and custom status line when switching Copilot Fusion profiles
• Prevent @ file mentions and /sandbox path completion from selecting outdated suggestions when typing quickly
• The /sandbox Credentials tab counts masked environment variables separately from unmasked suggestions
• /resume keeps session rows aligned and columns visible with --screen-reader, and announces unread status once
• Show all rows of wrapped Japanese, Chinese, and Korean text without clipping the last row or leaving extra blank rows
• Resizing the terminal during a text-selection drag preserves the clipboard instead of copying empty lines or unhighlighted text
• Keep the @ file picker up to date when ignore files change above the working directory
• Autopilot confirmation hides Assisted Permissions when disabled by administrator policy and explains why they are unavailable.
• Keep /config view tabs and the selected view readable in screen-reader mode on narrow terminals
• Exiting the CLI on macOS and Linux now stops attached background shells even when they ignore termination signals.
• Sandboxed MCP startup errors identify refused filesystem operations even when the server prints a stack trace
• /mcp token counts exclude tools deferred by client-side tool search
• Preserve freshly pasted text when stashing or opening the external editor, and prevent Ctrl+D from exiting while a paste is pending
• Prevent the # issue and pull request picker from selecting outdated results when typing quickly
• /plugin Details shows repository-local plugins without a User scope label and keeps versions separate from descriptions
• Workspace MCP servers resolve relative working directories from their config's directory level, including after /cd or when launching from a subdirectory
• /mcp delete removes a server without restarting other connected MCP servers
• Keep Sessions sidebar and shell shortcut hints readable in narrow terminals by hiding hints that do not fit
• Queued Copilot Fusion routing-profile changes show an acknowledgement when the current turn ends, before the next prompt.
• Keep /diff responsive with large untracked files and show untracked symlinks by their target paths instead of their contents
• HTML exports and rich-text copies preserve generic types and placeholders written in angle brackets, such as Vec and
• Allow image generation when settings.json is empty or contains only whitespace
• Keep the current location highlighted and announced to screen readers in narrow /config views while the area list has focus.
• Installing MCP servers from the registry with optional fields left blank now preserves server defaults instead of saving placeholder text
• Show agent IDs in /subagents when custom agents share a name, so you can tell which agent you configure
• Keep /ask and /btw question headers in plain text when pasting colored terminal output or control characters
• Keep the terminal's own colors in editors opened with Ctrl+G and shells opened with $ when the CLI's theme changes
• MCP registry installs preserve npm launch arguments when the server already includes an install confirmation flag
• Keep text typed immediately after a paste separate, so pasted image paths attach correctly and text after long pastes remains editable
• Keep /config view tabs intact and the selected area visible on narrow terminals
• Editor shortcuts stay inactive while the CLI exits, keeping the terminal ready for the shell
• Show MCP servers that return an empty authentication challenge in the /mcp auth picker
• Pasting text into Ctrl+R history search ignores escape sequences so matches, colors, and cursor placement stay correct
• Pasting colored text into /plugin, /skills, and /mcp search matches the visible text and preserves dashboard colors
• Emoji stay readable under the cursor in /model search, and long /diff search queries scroll on one line
• Long search queries in the Sessions tab and /resume wrap correctly and keep the cursor aligned with typed text.
• /diff lists copied files correctly when Git copy detection is enabled and preserves files whose names end in spaces
• Keep Copilot model access when account lookups are rate-limited
• Keep the exit status of a collapsed failed shell row whole in narrow terminals, and show as much of the command description as fits beside it
• Deleting a session through the SDK while one of its client tools is running now cancels that tool's handler, instead of leaving it running after the session is gone.
• A GITHUB_ASKPASS helper that never answers no longer stalls startup for over five minutes; sign-in now fails after one helper timeout
• After /code hands a session off to VS Code, resuming that session in the same window and switching back no longer brings back the notice that it is open in VS Code Chat
• Keep Windows drive letters with their paths when wrapping command previews in approval dialogs
• A config.json that cannot be read, such as one with an extra closing brace or one cut short by an interrupted write, is no longer replaced at startup by a file holding only firstLaunchAt; its trusted folders, plugins, marketplaces and other saved state stay in the file
• MCP enable/disable and plugin commands work when settings.json is empty
• A remote MCP server that refuses or closes the first connection at session start, for example while it is still starting, is retried as planned instead of staying failed for the rest of the session
• With sidebar.hoverFocus off and sidebar.showCloseButton on, moving the mouse over a Sessions sidebar card no longer moves the selection onto it
• Copying an answer with the mouse keeps the blank lines inside blockquotes
• The "Compacting conversation history" counter keeps counting from when the compaction started after the queue manager is opened and closed, instead of restarting at 0
• A plugin whose plugin.json location holds a named pipe or a link to a device such as /dev/zero no longer hangs or exhausts memory when skills, prompts or plugin lists load it; the file is skipped like an unreadable manifest
• Shell tool results no longer keep terminal escape sequences or hyperlink targets when a sequence is split across two reads of the command's output, as happens with coloured output larger than one read
• After /compact, the runtime no longer keeps a CPU core busy until the next event, and the session's live event stream no longer skips events that arrive after a compaction removed earlier ones
• A permission_prompt notification hook no longer runs for a request that Assisted Permissions approves without asking
• Adding or changing a repository's GitHub remote while the CLI is running is now picked up straight away, so /pr no longer keeps saying the repository is not connected to GitHub until the CLI restarts.
• When an extension fails to load, its log now shows the full error report, including the file and line of a syntax error, the stack trace and any cause, instead of a single line.
• The Sessions sidebar row of the session you are in shows it working for the whole of a running turn, and screen readers hear "status working" instead of "status done"
• With Auto selected, the footer's context percentage and the status line's displayed_context_limit now use the window of the model Auto routed to, matching /context, instead of a fixed 200,000 tokens
• The standalone CLI now re-extracts its cached package when cli-native.node has gone missing from it, instead of failing on every start with Native addon "cli-native" not found
• A workflow run that a session filesystem SQLite provider committed but reported as postCommitAmbiguous now starts, instead of failing and leaving a pending run that cannot be cancelled or resumed
• An extension prompt asking for many sensitive environment variables on a short terminal now keeps the first listed name and the count of the rest on screen instead of scrolling every name out of view
• The CLI's selection copies inline code and color swatches without decorative padding when their background color is shown
• Context from multiple userPromptSubmitted hooks now reaches the model instead of only the last hook's context
• Show organization support links in policy guidance and managed settings notices
• Indexed search becomes available sooner after restarting, and its enabled notice appears only when the index can serve searches.