diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 8de679798..ecb8a9d1b 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -432,6 +432,7 @@ dependencies = [
  "flate2",
  "futures-util",
  "getrandom 0.2.17",
+ "github-copilot-shell-tasks",
  "http",
  "indexmap",
  "libloading",
@@ -457,6 +458,14 @@ dependencies = [
  "zip",
 ]
 
+[[package]]
+name = "github-copilot-shell-tasks"
+version = "0.0.0-dev"
+dependencies = [
+ "windows",
+ "windows-core",
+]
+
 [[package]]
 name = "h2"
 version = "0.4.15"
@@ -2042,12 +2051,107 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "windows"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
+dependencies = [
+ "windows-collections",
+ "windows-core",
+ "windows-future",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
+dependencies = [
+ "windows-core",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
+dependencies = [
+ "windows-core",
+ "windows-link",
+ "windows-threading",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
+[[package]]
+name = "windows-numerics"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
+dependencies = [
+ "windows-core",
+ "windows-link",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -2106,6 +2210,15 @@ dependencies = [
  "windows_x86_64_msvc 0.52.6",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 0f18a9b15..4816e4cb7 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -27,12 +27,25 @@ include = [
 [lib]
 name = "github_copilot_sdk"
 
+# This manifest is both the root package and the workspace root. The standalone
+# `github-copilot-shell-tasks` crate is a member so it builds/tests with the
+# workspace and can be depended on by path above.
+[workspace]
+members = ["crates/github-copilot-shell-tasks"]
+resolver = "3"
+
 [features]
 default = ["bundled-cli"]
 bundled-cli = ["dep:tar", "dep:flate2", "dep:zip"]
 bundled-in-process = ["bundled-cli", "dep:libloading"]
 derive = ["dep:schemars"]
 test-support = []
+# Shared `Windows.UI.Shell.Tasks` ("Forerunner" / taskbar presence) integration,
+# re-exported as the `shell_tasks` module. Off by default to keep the base SDK
+# lean. Enabling it pulls the standalone, build.rs-free
+# `github-copilot-shell-tasks` crate (its `windows` / `windows-core` deps only
+# activate on Windows), mirroring how `bundled-cli` gates its optional `zip`.
+shell-tasks = ["dep:github-copilot-shell-tasks"]
 
 # Build docs.rs documentation with all features so feature-gated APIs
 # (e.g. `define_tool`, `schema_for`) appear and intra-doc links resolve.
@@ -59,6 +72,10 @@ getrandom = "0.2"
 uuid = { version = "1", default-features = false, features = ["v4"] }
 flate2 = { version = "1", optional = true }
 tar = { version = "0.4", optional = true }
+# Shared Windows.UI.Shell.Tasks integration, re-exported as `shell_tasks` behind
+# the `shell-tasks` feature. Standalone + build.rs-free so enabling it does not
+# perturb the base SDK; its Windows-only WinRT deps activate only on Windows.
+github-copilot-shell-tasks = { version = "0.0.0-dev", path = "crates/github-copilot-shell-tasks", optional = true }
 # LLM inference callback transport: idiomatic HTTP/WebSocket forwarding for the
 # `CopilotRequestHandler`, plus base64/byte/stream plumbing for the chunk protocol.
 base64 = "0.22"
diff --git a/rust/crates/github-copilot-shell-tasks/Cargo.toml b/rust/crates/github-copilot-shell-tasks/Cargo.toml
new file mode 100644
index 000000000..3ef915d42
--- /dev/null
+++ b/rust/crates/github-copilot-shell-tasks/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "github-copilot-shell-tasks"
+version = "0.0.0-dev"
+edition = "2024"
+rust-version = "1.94.0"
+description = "Shared Windows.UI.Shell.Tasks (Forerunner / taskbar presence) integration for GitHub Copilot, consumable by the desktop app and CLI without the full SDK client."
+keywords = ["copilot", "github", "windows", "taskbar", "forerunner"]
+categories = ["os::windows-apis", "api-bindings"]
+repository = "https://github.com/github/copilot-sdk"
+homepage = "https://github.com/github/copilot-sdk"
+license = "MIT"
+
+[lib]
+name = "github_copilot_shell_tasks"
+
+# Intentionally lightweight: no build.rs, and the only dependencies are the
+# Windows-only WinRT crates. This lets a napi addon (CLI) or Tauri backend (app)
+# depend on the shared integration without dragging in the `github-copilot-sdk`
+# client crate (JSON-RPC, tokio, and its network-touching build.rs).
+[dependencies]
+
+# `Foundation` covers the projection's `DateTime`/`IReference`/`Uri`;
+# `ApplicationModel` + `Management_Deployment` + `Win32_System_Com` back the
+# sparse-identity registrar (`sparse`); `windows-core` provides the WinRT
+# runtime. Declared under `cfg(windows)` so non-Windows builds pull neither
+# crate and the whole crate compiles as a pure-`std` no-op.
+[target.'cfg(windows)'.dependencies]
+windows = { version = "0.62", features = [
+    "Foundation",
+    "ApplicationModel",
+    "Management_Deployment",
+    "Win32_System_Com",
+] }
+windows-core = "0.62"
diff --git a/rust/crates/github-copilot-shell-tasks/src/bindings.rs b/rust/crates/github-copilot-shell-tasks/src/bindings.rs
new file mode 100644
index 000000000..1df353add
--- /dev/null
+++ b/rust/crates/github-copilot-shell-tasks/src/bindings.rs
@@ -0,0 +1,839 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+// VENDORED WinRT PROJECTIONS — DO NOT EDIT BY HAND.
+//
+// Generated by `windows-bindgen` 0.61 from the Windows.UI.Shell.Tasks.AppTaskContract
+// winmd shipped in the installed Windows SDK. To regenerate (Windows, with the 10.0.26100.0
+// SDK installed), run a throwaway crate depending on `windows-bindgen = "0.61"` with:
+//
+//   windows_bindgen::bindgen([
+//       "--in",
+//       r"C:\Program Files (x86)\Windows Kits\10\References\10.0.26100.0\Windows.UI.Shell.Tasks.AppTaskContract\2.0.0.0\Windows.UI.Shell.Tasks.AppTaskContract.winmd",
+//       "default",
+//       "--out", "apptask_bindings.rs",
+//       "--filter", "Windows.UI.Shell.Tasks",
+//       "--reference", "windows,skip-root,Windows",
+//   ]);
+//
+// The API is [experimental] and absent from the public `windows` crate metadata, so we
+// project it locally from the SDK winmd. `Windows.Foundation.*` types resolve to the
+// `windows` crate via the `--reference` mapping above.
+// Bindings generated by `windows-bindgen` 0.61.1
+
+#![allow(
+    non_snake_case,
+    non_upper_case_globals,
+    non_camel_case_types,
+    dead_code,
+    clippy::all
+)]
+
+pub mod Windows {
+    pub mod UI {
+        pub mod Shell {
+            pub mod Tasks {
+                #[repr(transparent)]
+                #[derive(Clone, Debug, Eq, PartialEq)]
+                pub struct AppTaskContent(windows_core::IUnknown);
+                windows_core::imp::interface_hierarchy!(
+                    AppTaskContent,
+                    windows_core::IUnknown,
+                    windows_core::IInspectable
+                );
+                impl AppTaskContent {
+                    pub fn AddButton<P1>(
+                        &self,
+                        text: &windows_core::HSTRING,
+                        actionuri: P1,
+                    ) -> windows_core::Result<()>
+                    where
+                        P1: windows_core::Param<windows::Foundation::Uri>,
+                    {
+                        let this = self;
+                        unsafe {
+                            (windows_core::Interface::vtable(this).AddButton)(
+                                windows_core::Interface::as_raw(this),
+                                core::mem::transmute_copy(text),
+                                actionuri.param().abi(),
+                            )
+                            .ok()
+                        }
+                    }
+
+                    pub fn SetTextInput(
+                        &self,
+                        placeholdertext: &windows_core::HSTRING,
+                        actionuritemplate: &windows_core::HSTRING,
+                    ) -> windows_core::Result<()> {
+                        let this = self;
+                        unsafe {
+                            (windows_core::Interface::vtable(this).SetTextInput)(
+                                windows_core::Interface::as_raw(this),
+                                core::mem::transmute_copy(placeholdertext),
+                                core::mem::transmute_copy(actionuritemplate),
+                            )
+                            .ok()
+                        }
+                    }
+
+                    pub fn SetQuestion(
+                        &self,
+                        question: &windows_core::HSTRING,
+                    ) -> windows_core::Result<()> {
+                        let this = self;
+                        unsafe {
+                            (windows_core::Interface::vtable(this).SetQuestion)(
+                                windows_core::Interface::as_raw(this),
+                                core::mem::transmute_copy(question),
+                            )
+                            .ok()
+                        }
+                    }
+
+                    pub fn CreateSequenceOfSteps(
+                        completedsteps: &[windows_core::HSTRING],
+                        executingstep: &windows_core::HSTRING,
+                    ) -> windows_core::Result<AppTaskContent> {
+                        Self::IAppTaskContentStatics(|this| unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).CreateSequenceOfSteps)(
+                                windows_core::Interface::as_raw(this),
+                                completedsteps.len().try_into().unwrap(),
+                                core::mem::transmute(completedsteps.as_ptr()),
+                                core::mem::transmute_copy(executingstep),
+                                &mut result__,
+                            )
+                            .and_then(|| windows_core::Type::from_abi(result__))
+                        })
+                    }
+
+                    pub fn CreatePreviewThumbnail<P0>(
+                        imageuri: P0,
+                        executingstep: &windows_core::HSTRING,
+                    ) -> windows_core::Result<AppTaskContent>
+                    where
+                        P0: windows_core::Param<windows::Foundation::Uri>,
+                    {
+                        Self::IAppTaskContentStatics(|this| unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).CreatePreviewThumbnail)(
+                                windows_core::Interface::as_raw(this),
+                                imageuri.param().abi(),
+                                core::mem::transmute_copy(executingstep),
+                                &mut result__,
+                            )
+                            .and_then(|| windows_core::Type::from_abi(result__))
+                        })
+                    }
+
+                    pub fn CreateTextSummaryResult(
+                        text: &windows_core::HSTRING,
+                    ) -> windows_core::Result<AppTaskContent> {
+                        Self::IAppTaskContentStatics(|this| unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).CreateTextSummaryResult)(
+                                windows_core::Interface::as_raw(this),
+                                core::mem::transmute_copy(text),
+                                &mut result__,
+                            )
+                            .and_then(|| windows_core::Type::from_abi(result__))
+                        })
+                    }
+
+                    pub fn CreateGeneratedAssetsResult(
+                        assets: &[Option<AppTaskResultAsset>],
+                    ) -> windows_core::Result<AppTaskContent> {
+                        Self::IAppTaskContentStatics(|this| unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).CreateGeneratedAssetsResult)(
+                                windows_core::Interface::as_raw(this),
+                                assets.len().try_into().unwrap(),
+                                core::mem::transmute(assets.as_ptr()),
+                                &mut result__,
+                            )
+                            .and_then(|| windows_core::Type::from_abi(result__))
+                        })
+                    }
+
+                    pub fn MaxButtons() -> windows_core::Result<u32> {
+                        Self::IAppTaskContentStatics(|this| unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).MaxButtons)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .map(|| result__)
+                        })
+                    }
+
+                    fn IAppTaskContentStatics<
+                        R,
+                        F: FnOnce(&IAppTaskContentStatics) -> windows_core::Result<R>,
+                    >(
+                        callback: F,
+                    ) -> windows_core::Result<R> {
+                        static SHARED: windows_core::imp::FactoryCache<
+                            AppTaskContent,
+                            IAppTaskContentStatics,
+                        > = windows_core::imp::FactoryCache::new();
+                        SHARED.call(callback)
+                    }
+                }
+                impl windows_core::RuntimeType for AppTaskContent {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_class::<Self, IAppTaskContent>();
+                }
+                unsafe impl windows_core::Interface for AppTaskContent {
+                    type Vtable = <IAppTaskContent as windows_core::Interface>::Vtable;
+
+                    const IID: windows_core::GUID =
+                        <IAppTaskContent as windows_core::Interface>::IID;
+                }
+                impl windows_core::RuntimeName for AppTaskContent {
+                    const NAME: &'static str = "Windows.UI.Shell.Tasks.AppTaskContent";
+                }
+                unsafe impl Send for AppTaskContent {}
+                unsafe impl Sync for AppTaskContent {}
+                #[repr(transparent)]
+                #[derive(Clone, Debug, Eq, PartialEq)]
+                pub struct AppTaskInfo(windows_core::IUnknown);
+                windows_core::imp::interface_hierarchy!(
+                    AppTaskInfo,
+                    windows_core::IUnknown,
+                    windows_core::IInspectable
+                );
+                impl AppTaskInfo {
+                    pub fn Remove(&self) -> windows_core::Result<()> {
+                        let this = self;
+                        unsafe {
+                            (windows_core::Interface::vtable(this).Remove)(
+                                windows_core::Interface::as_raw(this),
+                            )
+                            .ok()
+                        }
+                    }
+
+                    pub fn Update<P1>(
+                        &self,
+                        state: AppTaskState,
+                        content: P1,
+                    ) -> windows_core::Result<()>
+                    where
+                        P1: windows_core::Param<AppTaskContent>,
+                    {
+                        let this = self;
+                        unsafe {
+                            (windows_core::Interface::vtable(this).Update)(
+                                windows_core::Interface::as_raw(this),
+                                state,
+                                content.param().abi(),
+                            )
+                            .ok()
+                        }
+                    }
+
+                    pub fn UpdateState(&self, state: AppTaskState) -> windows_core::Result<()> {
+                        let this = self;
+                        unsafe {
+                            (windows_core::Interface::vtable(this).UpdateState)(
+                                windows_core::Interface::as_raw(this),
+                                state,
+                            )
+                            .ok()
+                        }
+                    }
+
+                    pub fn UpdateTitles(
+                        &self,
+                        title: &windows_core::HSTRING,
+                        subtitle: &windows_core::HSTRING,
+                    ) -> windows_core::Result<()> {
+                        let this = self;
+                        unsafe {
+                            (windows_core::Interface::vtable(this).UpdateTitles)(
+                                windows_core::Interface::as_raw(this),
+                                core::mem::transmute_copy(title),
+                                core::mem::transmute_copy(subtitle),
+                            )
+                            .ok()
+                        }
+                    }
+
+                    pub fn GetCompletedSteps(
+                        &self,
+                    ) -> windows_core::Result<windows_core::Array<windows_core::HSTRING>>
+                    {
+                        let this = self;
+                        unsafe {
+                            let mut result__ = core::mem::MaybeUninit::zeroed();
+                            (windows_core::Interface::vtable(this).GetCompletedSteps)(
+                                windows_core::Interface::as_raw(this),
+                                windows_core::Array::<windows_core::HSTRING>::set_abi_len(
+                                    core::mem::transmute(&mut result__),
+                                ),
+                                result__.as_mut_ptr() as *mut _ as _,
+                            )
+                            .map(|| result__.assume_init())
+                        }
+                    }
+
+                    pub fn GetExecutingStep(&self) -> windows_core::Result<windows_core::HSTRING> {
+                        let this = self;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).GetExecutingStep)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .map(|| core::mem::transmute(result__))
+                        }
+                    }
+
+                    pub fn Title(&self) -> windows_core::Result<windows_core::HSTRING> {
+                        let this = self;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).Title)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .map(|| core::mem::transmute(result__))
+                        }
+                    }
+
+                    pub fn Subtitle(&self) -> windows_core::Result<windows_core::HSTRING> {
+                        let this = self;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).Subtitle)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .map(|| core::mem::transmute(result__))
+                        }
+                    }
+
+                    pub fn DeepLink(&self) -> windows_core::Result<windows::Foundation::Uri> {
+                        let this = self;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).DeepLink)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .and_then(|| windows_core::Type::from_abi(result__))
+                        }
+                    }
+
+                    pub fn IconUri(&self) -> windows_core::Result<windows::Foundation::Uri> {
+                        let this = self;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).IconUri)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .and_then(|| windows_core::Type::from_abi(result__))
+                        }
+                    }
+
+                    pub fn State(&self) -> windows_core::Result<AppTaskState> {
+                        let this = self;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).State)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .map(|| result__)
+                        }
+                    }
+
+                    pub fn StartTime(&self) -> windows_core::Result<windows::Foundation::DateTime> {
+                        let this = self;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).StartTime)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .map(|| result__)
+                        }
+                    }
+
+                    pub fn EndTime(
+                        &self,
+                    ) -> windows_core::Result<
+                        windows::Foundation::IReference<windows::Foundation::DateTime>,
+                    > {
+                        let this = self;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).EndTime)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .and_then(|| windows_core::Type::from_abi(result__))
+                        }
+                    }
+
+                    pub fn Id(&self) -> windows_core::Result<windows_core::HSTRING> {
+                        let this = &windows_core::Interface::cast::<IAppTaskInfo2>(self)?;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).Id)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .map(|| core::mem::transmute(result__))
+                        }
+                    }
+
+                    pub fn HiddenByUser(&self) -> windows_core::Result<bool> {
+                        let this = &windows_core::Interface::cast::<IAppTaskInfo2>(self)?;
+                        unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).HiddenByUser)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .map(|| result__)
+                        }
+                    }
+
+                    pub fn UpdateDeepLink<P0>(&self, deeplink: P0) -> windows_core::Result<()>
+                    where
+                        P0: windows_core::Param<windows::Foundation::Uri>,
+                    {
+                        let this = &windows_core::Interface::cast::<IAppTaskInfo2>(self)?;
+                        unsafe {
+                            (windows_core::Interface::vtable(this).UpdateDeepLink)(
+                                windows_core::Interface::as_raw(this),
+                                deeplink.param().abi(),
+                            )
+                            .ok()
+                        }
+                    }
+
+                    pub fn IsSupported() -> windows_core::Result<bool> {
+                        Self::IAppTaskInfoStatics(|this| unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).IsSupported)(
+                                windows_core::Interface::as_raw(this),
+                                &mut result__,
+                            )
+                            .map(|| result__)
+                        })
+                    }
+
+                    pub fn FindAll() -> windows_core::Result<windows_core::Array<AppTaskInfo>> {
+                        Self::IAppTaskInfoStatics(|this| unsafe {
+                            let mut result__ = core::mem::MaybeUninit::zeroed();
+                            (windows_core::Interface::vtable(this).FindAll)(
+                                windows_core::Interface::as_raw(this),
+                                windows_core::Array::<AppTaskInfo>::set_abi_len(
+                                    core::mem::transmute(&mut result__),
+                                ),
+                                result__.as_mut_ptr() as *mut _ as _,
+                            )
+                            .map(|| result__.assume_init())
+                        })
+                    }
+
+                    pub fn Create<P2, P3, P4>(
+                        title: &windows_core::HSTRING,
+                        subtitle: &windows_core::HSTRING,
+                        deeplink: P2,
+                        iconuri: P3,
+                        content: P4,
+                    ) -> windows_core::Result<AppTaskInfo>
+                    where
+                        P2: windows_core::Param<windows::Foundation::Uri>,
+                        P3: windows_core::Param<windows::Foundation::Uri>,
+                        P4: windows_core::Param<AppTaskContent>,
+                    {
+                        Self::IAppTaskInfoStatics(|this| unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).Create)(
+                                windows_core::Interface::as_raw(this),
+                                core::mem::transmute_copy(title),
+                                core::mem::transmute_copy(subtitle),
+                                deeplink.param().abi(),
+                                iconuri.param().abi(),
+                                content.param().abi(),
+                                &mut result__,
+                            )
+                            .and_then(|| windows_core::Type::from_abi(result__))
+                        })
+                    }
+
+                    fn IAppTaskInfoStatics<
+                        R,
+                        F: FnOnce(&IAppTaskInfoStatics) -> windows_core::Result<R>,
+                    >(
+                        callback: F,
+                    ) -> windows_core::Result<R> {
+                        static SHARED: windows_core::imp::FactoryCache<
+                            AppTaskInfo,
+                            IAppTaskInfoStatics,
+                        > = windows_core::imp::FactoryCache::new();
+                        SHARED.call(callback)
+                    }
+                }
+                impl windows_core::RuntimeType for AppTaskInfo {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_class::<Self, IAppTaskInfo>();
+                }
+                unsafe impl windows_core::Interface for AppTaskInfo {
+                    type Vtable = <IAppTaskInfo as windows_core::Interface>::Vtable;
+
+                    const IID: windows_core::GUID = <IAppTaskInfo as windows_core::Interface>::IID;
+                }
+                impl windows_core::RuntimeName for AppTaskInfo {
+                    const NAME: &'static str = "Windows.UI.Shell.Tasks.AppTaskInfo";
+                }
+                unsafe impl Send for AppTaskInfo {}
+                unsafe impl Sync for AppTaskInfo {}
+                #[repr(transparent)]
+                #[derive(Clone, Debug, Eq, PartialEq)]
+                pub struct AppTaskResultAsset(windows_core::IUnknown);
+                windows_core::imp::interface_hierarchy!(
+                    AppTaskResultAsset,
+                    windows_core::IUnknown,
+                    windows_core::IInspectable
+                );
+                impl AppTaskResultAsset {
+                    pub fn CreateInstance<P2, P3>(
+                        name: &windows_core::HSTRING,
+                        context: &windows_core::HSTRING,
+                        iconuri: P2,
+                        asseturi: P3,
+                    ) -> windows_core::Result<AppTaskResultAsset>
+                    where
+                        P2: windows_core::Param<windows::Foundation::Uri>,
+                        P3: windows_core::Param<windows::Foundation::Uri>,
+                    {
+                        Self::IAppTaskResultAssetFactory(|this| unsafe {
+                            let mut result__ = core::mem::zeroed();
+                            (windows_core::Interface::vtable(this).CreateInstance)(
+                                windows_core::Interface::as_raw(this),
+                                core::mem::transmute_copy(name),
+                                core::mem::transmute_copy(context),
+                                iconuri.param().abi(),
+                                asseturi.param().abi(),
+                                &mut result__,
+                            )
+                            .and_then(|| windows_core::Type::from_abi(result__))
+                        })
+                    }
+
+                    fn IAppTaskResultAssetFactory<
+                        R,
+                        F: FnOnce(&IAppTaskResultAssetFactory) -> windows_core::Result<R>,
+                    >(
+                        callback: F,
+                    ) -> windows_core::Result<R> {
+                        static SHARED: windows_core::imp::FactoryCache<
+                            AppTaskResultAsset,
+                            IAppTaskResultAssetFactory,
+                        > = windows_core::imp::FactoryCache::new();
+                        SHARED.call(callback)
+                    }
+                }
+                impl windows_core::RuntimeType for AppTaskResultAsset {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_class::<Self, IAppTaskResultAsset>();
+                }
+                unsafe impl windows_core::Interface for AppTaskResultAsset {
+                    type Vtable = <IAppTaskResultAsset as windows_core::Interface>::Vtable;
+
+                    const IID: windows_core::GUID =
+                        <IAppTaskResultAsset as windows_core::Interface>::IID;
+                }
+                impl windows_core::RuntimeName for AppTaskResultAsset {
+                    const NAME: &'static str = "Windows.UI.Shell.Tasks.AppTaskResultAsset";
+                }
+                unsafe impl Send for AppTaskResultAsset {}
+                unsafe impl Sync for AppTaskResultAsset {}
+                #[repr(transparent)]
+                #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+                pub struct AppTaskState(pub i32);
+                impl AppTaskState {
+                    pub const Completed: Self = Self(1i32);
+                    pub const Error: Self = Self(4i32);
+                    pub const NeedsAttention: Self = Self(2i32);
+                    pub const Paused: Self = Self(3i32);
+                    pub const Running: Self = Self(0i32);
+                }
+                impl windows_core::TypeKind for AppTaskState {
+                    type TypeKind = windows_core::CopyType;
+                }
+                impl windows_core::RuntimeType for AppTaskState {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::from_slice(
+                            b"enum(Windows.UI.Shell.Tasks.AppTaskState;i4)",
+                        );
+                }
+                windows_core::imp::define_interface!(
+                    IAppTaskContent,
+                    IAppTaskContent_Vtbl,
+                    0x2411bf59_1b2d_5b63_8181_03d6c2248a68
+                );
+                impl windows_core::RuntimeType for IAppTaskContent {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_interface::<Self>();
+                }
+                #[repr(C)]
+                #[doc(hidden)]
+                pub struct IAppTaskContent_Vtbl {
+                    pub base__: windows_core::IInspectable_Vtbl,
+                    pub AddButton: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub SetTextInput: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub SetQuestion: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                }
+                windows_core::imp::define_interface!(
+                    IAppTaskContentStatics,
+                    IAppTaskContentStatics_Vtbl,
+                    0xaabd19f6_7afc_5b1b_94f6_5dc9dc9af9e7
+                );
+                impl windows_core::RuntimeType for IAppTaskContentStatics {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_interface::<Self>();
+                }
+                #[repr(C)]
+                #[doc(hidden)]
+                pub struct IAppTaskContentStatics_Vtbl {
+                    pub base__: windows_core::IInspectable_Vtbl,
+                    pub CreateSequenceOfSteps: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        u32,
+                        *const windows_core::HSTRING,
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub CreatePreviewThumbnail: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub CreateTextSummaryResult: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub CreateGeneratedAssetsResult:
+                        unsafe extern "system" fn(
+                            *mut core::ffi::c_void,
+                            u32,
+                            *const AppTaskResultAsset,
+                            *mut *mut core::ffi::c_void,
+                        ) -> windows_core::HRESULT,
+                    pub MaxButtons: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut u32,
+                    )
+                        -> windows_core::HRESULT,
+                }
+                windows_core::imp::define_interface!(
+                    IAppTaskInfo,
+                    IAppTaskInfo_Vtbl,
+                    0x6720eed6_435b_5db9_be66_9343b70654f7
+                );
+                impl windows_core::RuntimeType for IAppTaskInfo {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_interface::<Self>();
+                }
+                #[repr(C)]
+                #[doc(hidden)]
+                pub struct IAppTaskInfo_Vtbl {
+                    pub base__: windows_core::IInspectable_Vtbl,
+                    pub Remove:
+                        unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
+                    pub Update: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        AppTaskState,
+                        *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub UpdateState: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        AppTaskState,
+                    )
+                        -> windows_core::HRESULT,
+                    pub UpdateTitles: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub GetCompletedSteps: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut u32,
+                        *mut *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub GetExecutingStep: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub Title: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub Subtitle: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub DeepLink: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub IconUri: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub State: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut AppTaskState,
+                    )
+                        -> windows_core::HRESULT,
+                    pub StartTime: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut windows::Foundation::DateTime,
+                    )
+                        -> windows_core::HRESULT,
+                    pub EndTime: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                }
+                windows_core::imp::define_interface!(
+                    IAppTaskInfo2,
+                    IAppTaskInfo2_Vtbl,
+                    0xad724d71_f137_51c0_8111_3552436bf447
+                );
+                impl windows_core::RuntimeType for IAppTaskInfo2 {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_interface::<Self>();
+                }
+                #[repr(C)]
+                #[doc(hidden)]
+                pub struct IAppTaskInfo2_Vtbl {
+                    pub base__: windows_core::IInspectable_Vtbl,
+                    pub Id: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    ) -> windows_core::HRESULT,
+                    pub HiddenByUser: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut bool,
+                    )
+                        -> windows_core::HRESULT,
+                    pub UpdateDeepLink: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                }
+                windows_core::imp::define_interface!(
+                    IAppTaskInfoStatics,
+                    IAppTaskInfoStatics_Vtbl,
+                    0xa0b0434f_c640_5800_88c9_d7691ac2f48f
+                );
+                impl windows_core::RuntimeType for IAppTaskInfoStatics {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_interface::<Self>();
+                }
+                #[repr(C)]
+                #[doc(hidden)]
+                pub struct IAppTaskInfoStatics_Vtbl {
+                    pub base__: windows_core::IInspectable_Vtbl,
+                    pub IsSupported: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut bool,
+                    )
+                        -> windows_core::HRESULT,
+                    pub FindAll: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut u32,
+                        *mut *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                    pub Create: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                }
+                windows_core::imp::define_interface!(
+                    IAppTaskResultAsset,
+                    IAppTaskResultAsset_Vtbl,
+                    0x75d0c2b3_8a31_5f8f_bda4_bdca96e95532
+                );
+                impl windows_core::RuntimeType for IAppTaskResultAsset {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_interface::<Self>();
+                }
+                #[repr(C)]
+                #[doc(hidden)]
+                pub struct IAppTaskResultAsset_Vtbl {
+                    pub base__: windows_core::IInspectable_Vtbl,
+                }
+                windows_core::imp::define_interface!(
+                    IAppTaskResultAssetFactory,
+                    IAppTaskResultAssetFactory_Vtbl,
+                    0x0334d9df_0e06_5999_ba41_85d72e980085
+                );
+                impl windows_core::RuntimeType for IAppTaskResultAssetFactory {
+                    const SIGNATURE: windows_core::imp::ConstBuffer =
+                        windows_core::imp::ConstBuffer::for_interface::<Self>();
+                }
+                #[repr(C)]
+                #[doc(hidden)]
+                pub struct IAppTaskResultAssetFactory_Vtbl {
+                    pub base__: windows_core::IInspectable_Vtbl,
+                    pub CreateInstance: unsafe extern "system" fn(
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut core::ffi::c_void,
+                        *mut *mut core::ffi::c_void,
+                    )
+                        -> windows_core::HRESULT,
+                }
+            }
+        }
+    }
+}
diff --git a/rust/crates/github-copilot-shell-tasks/src/content.rs b/rust/crates/github-copilot-shell-tasks/src/content.rs
new file mode 100644
index 000000000..336bb2900
--- /dev/null
+++ b/rust/crates/github-copilot-shell-tasks/src/content.rs
@@ -0,0 +1,301 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+//! Data-driven builder for `Windows.UI.Shell.Tasks.AppTaskContent` — the one
+//! piece of the Forerunner engine that the Copilot desktop app and the CLI
+//! implement *identically*.
+//!
+//! Both products translate their own domain state into the same fixed sequence
+//! of WinRT calls: create a base content shape (a step sequence, a preview
+//! thumbnail, a text summary, or a generated-assets grid), then optionally
+//! attach a question, action buttons, and a text input. Only the *source* of
+//! that data differs — the CLI feeds a flat napi options struct dispatched by a
+//! template string; the app feeds domain `AttentionRequest` / activity-timeline
+//! state and builds its own deep links. This module captures the common tail as
+//! a neutral [`ContentSpec`] plus a `build_content` function so neither
+//! product hand-rolls the WinRT call sequence.
+//!
+//! The spec types are pure data (cross-platform, unit-testable). The functions
+//! that actually call WinRT are `#[cfg(windows)]` and operate on the vendored
+//! projection in `super::bindings`; each product keeps its own worker thread,
+//! object registry, deep-link grammar, and telemetry as a thin adapter that
+//! maps its state into a [`ContentSpec`] and calls `build_content`.
+//!
+//! # Faithfulness
+//!
+//! `build_content` applies the question, then every button in order, then the
+//! text input — the exact order both products use. Because each product only
+//! populates the fields it uses (the app never sets both buttons and a text
+//! input; the CLI passes through whatever its caller supplied), the union
+//! builder reproduces each product's current WinRT calls byte-for-byte. Product
+//! specific preparation that is *not* shared — the CLI's template-string
+//! dispatch, the app's 12-asset cap, `file://` URI resolution, and per-asset
+//! icon choice — stays in each adapter, which hands this module an already
+//! resolved [`ContentSpec`].
+
+/// A single generated asset shown in the [`ContentBody::Assets`] result grid.
+/// Maps to a `Windows.UI.Shell.Tasks.AppTaskResultAsset`. All URIs are already
+/// resolved to forms the shell can open (`ms-appx:///…`, `file:///…`, or an
+/// absolute path); resolution and filtering are the caller's responsibility.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResultAsset {
+    /// Display name of the generated asset.
+    pub name: String,
+    /// Contextual description shown alongside the asset.
+    pub context: String,
+    /// Icon URI representing the asset (an image asset typically uses itself).
+    pub icon_uri: String,
+    /// URI launched when the asset is activated.
+    pub asset_uri: String,
+}
+
+/// The base content shape of a task's hover card, before any interactive
+/// elements are attached. Each variant maps 1:1 to an `AppTaskContent::Create*`
+/// factory.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ContentBody {
+    /// A sequence of completed step labels plus the currently executing step
+    /// (`AppTaskContent::CreateSequenceOfSteps`). The common running-progress
+    /// shape.
+    Steps {
+        /// Completed step labels, in order.
+        completed_steps: Vec<String>,
+        /// The step currently executing (empty string for none).
+        current_step: String,
+    },
+    /// A preview image captioned with the current step
+    /// (`AppTaskContent::CreatePreviewThumbnail`).
+    Preview {
+        /// Preview image URI.
+        image_uri: String,
+        /// Caption shown under the preview (typically the current step).
+        caption: String,
+    },
+    /// A plain result summary (`AppTaskContent::CreateTextSummaryResult`).
+    Summary {
+        /// Result summary text.
+        text: String,
+    },
+    /// A grid of generated assets (`AppTaskContent::CreateGeneratedAssetsResult`).
+    Assets {
+        /// The assets to show, already resolved and capped by the caller.
+        assets: Vec<ResultAsset>,
+    },
+}
+
+/// A clickable button attached to a task's hover card. The shell caps the count
+/// (currently 2); this builder applies every button supplied, matching both
+/// products, and leaves the cap to the caller/shell.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Button {
+    /// Button label.
+    pub text: String,
+    /// URI launched when the button is clicked.
+    pub action_uri: String,
+}
+
+/// A single-line text input attached to a task's hover card. Submitted text is
+/// substituted into `action_uri_template` by the shell and the result launched.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TextInput {
+    /// Placeholder text shown in the empty input.
+    pub placeholder: String,
+    /// URI template the submitted text is substituted into.
+    pub action_uri_template: String,
+}
+
+/// Everything needed to build one `AppTaskContent`: a base [`ContentBody`] plus
+/// the optional interactive elements attached on top. Interactive fields apply
+/// to any body and are what the `NeedsAttention` state uses (it requires a
+/// `question`).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ContentSpec {
+    /// The base content shape.
+    pub body: ContentBody,
+    /// A question shown to the user (required for the `NeedsAttention` state).
+    pub question: Option<String>,
+    /// Action buttons, applied in order.
+    pub buttons: Vec<Button>,
+    /// An optional text input.
+    pub text_input: Option<TextInput>,
+}
+
+impl ContentSpec {
+    /// Creates a spec with only a base body and no interactive elements — the
+    /// common non-attention case (a running-progress or result card).
+    #[must_use]
+    pub fn new(body: ContentBody) -> Self {
+        Self {
+            body,
+            question: None,
+            buttons: Vec::new(),
+            text_input: None,
+        }
+    }
+}
+
+#[cfg(windows)]
+mod imp {
+    use windows::Foundation::Uri;
+    use windows_core::HSTRING;
+
+    use super::super::bindings::Windows::UI::Shell::Tasks::{AppTaskContent, AppTaskResultAsset};
+    use super::{ContentBody, ContentSpec, ResultAsset};
+
+    /// Builds a `Windows.Foundation.Uri` from a string. URI validity is the
+    /// caller's responsibility (callers supply well-formed `ms-appx:///` /
+    /// `file:///` / absolute forms). Identical to the app's `uri` and the CLI's
+    /// `make_uri` helpers this replaces.
+    pub fn make_uri(value: &str) -> windows_core::Result<Uri> {
+        Uri::CreateUri(&HSTRING::from(value))
+    }
+
+    /// Builds one `AppTaskResultAsset` from a resolved [`ResultAsset`] spec via
+    /// `AppTaskResultAsset::CreateInstance(name, context, icon, asset)`.
+    pub fn make_result_asset(asset: &ResultAsset) -> windows_core::Result<AppTaskResultAsset> {
+        let icon = make_uri(&asset.icon_uri)?;
+        let target = make_uri(&asset.asset_uri)?;
+        AppTaskResultAsset::CreateInstance(
+            &HSTRING::from(&asset.name),
+            &HSTRING::from(&asset.context),
+            &icon,
+            &target,
+        )
+    }
+
+    /// Builds the base `AppTaskContent` for the spec's [`ContentBody`], then
+    /// attaches the question, buttons (in order), and text input. Reproduces the
+    /// exact WinRT call sequence both products currently hand-roll.
+    pub fn build_content(spec: &ContentSpec) -> windows_core::Result<AppTaskContent> {
+        let content = match &spec.body {
+            ContentBody::Steps {
+                completed_steps,
+                current_step,
+            } => {
+                let steps: Vec<HSTRING> = completed_steps.iter().map(HSTRING::from).collect();
+                AppTaskContent::CreateSequenceOfSteps(&steps, &HSTRING::from(current_step))?
+            }
+            ContentBody::Preview { image_uri, caption } => {
+                let image = make_uri(image_uri)?;
+                AppTaskContent::CreatePreviewThumbnail(&image, &HSTRING::from(caption))?
+            }
+            ContentBody::Summary { text } => {
+                AppTaskContent::CreateTextSummaryResult(&HSTRING::from(text))?
+            }
+            ContentBody::Assets { assets } => {
+                let assets: Vec<Option<AppTaskResultAsset>> = assets
+                    .iter()
+                    .map(|a| make_result_asset(a).map(Some))
+                    .collect::<windows_core::Result<Vec<_>>>()?;
+                AppTaskContent::CreateGeneratedAssetsResult(&assets)?
+            }
+        };
+
+        if let Some(question) = &spec.question {
+            content.SetQuestion(&HSTRING::from(question))?;
+        }
+        for button in &spec.buttons {
+            let action = make_uri(&button.action_uri)?;
+            content.AddButton(&HSTRING::from(&button.text), &action)?;
+        }
+        if let Some(input) = &spec.text_input {
+            content.SetTextInput(
+                &HSTRING::from(&input.placeholder),
+                &HSTRING::from(&input.action_uri_template),
+            )?;
+        }
+
+        Ok(content)
+    }
+}
+
+#[cfg(windows)]
+pub use imp::{build_content, make_result_asset, make_uri};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn new_spec_has_no_interactive_elements() {
+        let spec = ContentSpec::new(ContentBody::Summary {
+            text: "done".to_owned(),
+        });
+        assert_eq!(
+            spec.body,
+            ContentBody::Summary {
+                text: "done".to_owned()
+            }
+        );
+        assert!(spec.question.is_none());
+        assert!(spec.buttons.is_empty());
+        assert!(spec.text_input.is_none());
+    }
+
+    #[test]
+    fn steps_body_preserves_order_and_current() {
+        let body = ContentBody::Steps {
+            completed_steps: vec!["a".to_owned(), "b".to_owned()],
+            current_step: "c".to_owned(),
+        };
+        let ContentBody::Steps {
+            completed_steps,
+            current_step,
+        } = body
+        else {
+            unreachable!()
+        };
+        assert_eq!(completed_steps, ["a", "b"]);
+        assert_eq!(current_step, "c");
+    }
+
+    #[test]
+    fn attention_spec_carries_question_buttons_and_input() {
+        let spec = ContentSpec {
+            body: ContentBody::Steps {
+                completed_steps: Vec::new(),
+                current_step: "Working".to_owned(),
+            },
+            question: Some("Proceed?".to_owned()),
+            buttons: vec![
+                Button {
+                    text: "Yes".to_owned(),
+                    action_uri: "local+copilot://task-response/s?a=yes".to_owned(),
+                },
+                Button {
+                    text: "No".to_owned(),
+                    action_uri: "local+copilot://task-response/s?a=no".to_owned(),
+                },
+            ],
+            text_input: Some(TextInput {
+                placeholder: "Type a response".to_owned(),
+                action_uri_template: "local+copilot://task-response/s?t={input}".to_owned(),
+            }),
+        };
+        assert_eq!(spec.question.as_deref(), Some("Proceed?"));
+        assert_eq!(spec.buttons.len(), 2);
+        assert_eq!(spec.buttons[0].text, "Yes");
+        assert_eq!(
+            spec.text_input.as_ref().map(|t| t.placeholder.as_str()),
+            Some("Type a response")
+        );
+    }
+
+    #[test]
+    fn assets_body_holds_resolved_specs() {
+        let body = ContentBody::Assets {
+            assets: vec![ResultAsset {
+                name: "diagram.png".to_owned(),
+                context: "Generated image".to_owned(),
+                icon_uri: "file:///c:/tmp/diagram.png".to_owned(),
+                asset_uri: "file:///c:/tmp/diagram.png".to_owned(),
+            }],
+        };
+        let ContentBody::Assets { assets } = body else {
+            unreachable!()
+        };
+        assert_eq!(assets.len(), 1);
+        assert_eq!(assets[0].icon_uri, assets[0].asset_uri);
+    }
+}
diff --git a/rust/crates/github-copilot-shell-tasks/src/contract.rs b/rust/crates/github-copilot-shell-tasks/src/contract.rs
new file mode 100644
index 000000000..62c08c4de
--- /dev/null
+++ b/rust/crates/github-copilot-shell-tasks/src/contract.rs
@@ -0,0 +1,242 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+//! Shared cross-process contract for the taskbar hover-card round-trip.
+//!
+//! Two separate binaries cooperate to relay a hover-card interaction back into
+//! the running CLI:
+//!
+//! - **`copilot.exe`** (the `cli-native` addon) hosts the named-pipe server and
+//!   writes the focus *sidecar* file that carries the host window handle.
+//! - **`copilot-taskbar-activator.exe`** is protocol-activated by the shell,
+//!   connects to that pipe, and reads that sidecar.
+//!
+//! Because they are distinct processes (and, historically, distinct crates),
+//! the pipe name, the sidecar file name, and the sidecar payload format were
+//! duplicated in every producer/consumer site and had to be kept in lock-step
+//! by hand. This crate is the **single source of truth** for those contracts so
+//! the two ends cannot drift: both crates depend on it and call these functions
+//! instead of re-implementing the rules.
+//!
+//! The logic is pure (`std`-only, no Windows FFI) so it compiles on every
+//! platform and stays unit-testable; the Windows-specific I/O (creating the
+//! pipe, joining `%TEMP%`, reading/writing the file) stays in the respective
+//! callers.
+
+/// Prefix of the per-session named pipe, before the sanitized session id.
+pub const PIPE_NAME_PREFIX: &str = r"\\.\pipe\copilot-taskbar-";
+
+/// Prefix of the per-session focus sidecar file name, before the sanitized
+/// session id.
+pub const SIDECAR_FILE_PREFIX: &str = "copilot-taskbar-";
+
+/// Suffix (extension) of the per-session focus sidecar file name.
+pub const SIDECAR_FILE_SUFFIX: &str = ".hwnd";
+
+/// Sanitize a session id into the shared name stem used by both the pipe path
+/// and the sidecar file name. Every character outside `[A-Za-z0-9._-]` is
+/// replaced with `_`. Session ids are expected to be UUIDs, so in practice this
+/// is an identity transform; the rule exists so a non-UUID id can never produce
+/// an invalid pipe path or file name.
+#[must_use]
+pub fn sanitize_session_id(session_id: &str) -> String {
+    session_id
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-') {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect()
+}
+
+/// Full Windows named-pipe path for a session:
+/// `\\.\pipe\copilot-taskbar-<sanitized id>`.
+#[must_use]
+pub fn pipe_path_for_session(session_id: &str) -> String {
+    format!("{PIPE_NAME_PREFIX}{}", sanitize_session_id(session_id))
+}
+
+/// Bare file name (no directory) of the per-session focus sidecar:
+/// `copilot-taskbar-<sanitized id>.hwnd`. Callers join this onto the temp
+/// directory (`std::env::temp_dir()`) so the directory resolution stays in the
+/// Windows-specific caller while the name contract lives here.
+#[must_use]
+pub fn sidecar_file_name(session_id: &str) -> String {
+    format!(
+        "{SIDECAR_FILE_PREFIX}{}{SIDECAR_FILE_SUFFIX}",
+        sanitize_session_id(session_id)
+    )
+}
+
+/// The parsed contents of a focus sidecar file.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SidecarPayload {
+    /// The host window handle as a raw `isize` (the platform HWND value).
+    pub hwnd: isize,
+    /// The process id that owned the window at capture time, when recorded.
+    /// `None` for legacy sidecars written before owner-PID validation existed.
+    pub owner_pid: Option<u32>,
+    /// The terminal tab-match title (line 2), when present and non-blank.
+    pub match_text: Option<String>,
+}
+
+/// Build the sidecar file contents. Line 1 is `"<decimal HWND> <owner PID>"` —
+/// the host window handle plus the process id that owns it, captured at write
+/// time. An optional line 2 carries the tab-match text (the terminal tab title)
+/// for UI Automation tab selection in the activator. The match text is written
+/// only when it is non-blank so an empty/branding-only title never produces an
+/// over-broad "matches every Copilot tab" marker.
+///
+/// The owner PID lets the reader reject a *reused* HWND: top-level handles are
+/// recycled by the OS, so a stale sidecar could otherwise foreground an
+/// unrelated window that inherited the old handle value.
+#[must_use]
+pub fn format_sidecar(hwnd: isize, owner_pid: u32, match_text: Option<&str>) -> String {
+    let header = format!("{hwnd} {owner_pid}");
+    match match_text.map(str::trim).filter(|s| !s.is_empty()) {
+        Some(text) => format!("{header}\n{text}"),
+        None => header,
+    }
+}
+
+/// Parse focus sidecar file contents produced by [`format_sidecar`]. Line 1 is
+/// `"<decimal HWND> <owner PID>"` (the owner PID is optional for
+/// forward/backward compatibility); an optional line 2 carries the tab-match
+/// title. Returns `None` when the HWND is absent, unparsable, or zero — the
+/// same "no usable window" signal the reader treats as a missing sidecar.
+#[must_use]
+pub fn parse_sidecar(contents: &str) -> Option<SidecarPayload> {
+    let mut lines = contents.lines();
+    let mut header = lines.next()?.split_whitespace();
+    let hwnd: isize = header.next()?.trim().parse().ok()?;
+    if hwnd == 0 {
+        return None;
+    }
+    let owner_pid: Option<u32> = header.next().and_then(|p| p.parse().ok());
+    let match_text = lines
+        .next()
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .map(str::to_string);
+    Some(SidecarPayload {
+        hwnd,
+        owner_pid,
+        match_text,
+    })
+}
+
+/// Versioned contract test vectors for [`sanitize_session_id`], shared so every
+/// producer/consumer asserts the identical rule. Each tuple is
+/// `(input, expected sanitized stem)`.
+pub const SANITIZE_VECTORS: &[(&str, &str)] = &[
+    ("abc-123", "abc-123"),
+    (
+        "550e8400-e29b-41d4-a716-446655440000",
+        "550e8400-e29b-41d4-a716-446655440000",
+    ),
+    ("a/b:c d", "a_b_c_d"),
+    ("with.dot_and-dash", "with.dot_and-dash"),
+    ("slash\\back", "slash_back"),
+    ("unicode\u{00e9}", "unicode_"),
+];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sanitize_matches_contract_vectors() {
+        for (input, expected) in SANITIZE_VECTORS {
+            assert_eq!(sanitize_session_id(input), *expected, "input {input:?}");
+        }
+    }
+
+    #[test]
+    fn pipe_path_uses_prefix_and_sanitized_id() {
+        assert_eq!(
+            pipe_path_for_session("abc-123"),
+            r"\\.\pipe\copilot-taskbar-abc-123"
+        );
+        assert_eq!(
+            pipe_path_for_session("a/b:c d"),
+            r"\\.\pipe\copilot-taskbar-a_b_c_d"
+        );
+    }
+
+    #[test]
+    fn sidecar_file_name_uses_prefix_suffix_and_sanitized_id() {
+        assert_eq!(sidecar_file_name("abc-123"), "copilot-taskbar-abc-123.hwnd");
+        assert_eq!(sidecar_file_name("a/b:c d"), "copilot-taskbar-a_b_c_d.hwnd");
+    }
+
+    #[test]
+    fn format_sidecar_writes_hwnd_and_pid_without_match_text() {
+        assert_eq!(format_sidecar(12345, 6789, None), "12345 6789");
+    }
+
+    #[test]
+    fn format_sidecar_appends_non_blank_match_text() {
+        assert_eq!(
+            format_sidecar(12345, 6789, Some("Copilot - tab")),
+            "12345 6789\nCopilot - tab"
+        );
+    }
+
+    #[test]
+    fn format_sidecar_omits_blank_match_text() {
+        assert_eq!(format_sidecar(1, 2, Some("   ")), "1 2");
+    }
+
+    #[test]
+    fn format_sidecar_trims_match_text() {
+        assert_eq!(format_sidecar(1, 2, Some("  tab  ")), "1 2\ntab");
+    }
+
+    #[test]
+    fn round_trip_format_then_parse() {
+        let text = format_sidecar(98765, 4321, Some("My Tab"));
+        assert_eq!(
+            parse_sidecar(&text),
+            Some(SidecarPayload {
+                hwnd: 98765,
+                owner_pid: Some(4321),
+                match_text: Some("My Tab".to_string()),
+            })
+        );
+    }
+
+    #[test]
+    fn parse_rejects_zero_and_missing_hwnd() {
+        assert_eq!(parse_sidecar("0 1234"), None);
+        assert_eq!(parse_sidecar(""), None);
+        assert_eq!(parse_sidecar("notanumber"), None);
+    }
+
+    #[test]
+    fn parse_accepts_legacy_hwnd_only_sidecar() {
+        assert_eq!(
+            parse_sidecar("55555"),
+            Some(SidecarPayload {
+                hwnd: 55555,
+                owner_pid: None,
+                match_text: None,
+            })
+        );
+    }
+
+    #[test]
+    fn parse_ignores_blank_match_text_line() {
+        assert_eq!(
+            parse_sidecar("42 7\n   "),
+            Some(SidecarPayload {
+                hwnd: 42,
+                owner_pid: Some(7),
+                match_text: None,
+            })
+        );
+    }
+}
diff --git a/rust/crates/github-copilot-shell-tasks/src/lib.rs b/rust/crates/github-copilot-shell-tasks/src/lib.rs
new file mode 100644
index 000000000..65d7d9bae
--- /dev/null
+++ b/rust/crates/github-copilot-shell-tasks/src/lib.rs
@@ -0,0 +1,76 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+//! Shared Rust integration with the experimental `Windows.UI.Shell.Tasks`
+//! ("Forerunner" / taskbar presence) API.
+//!
+//! This crate is the single home for the pieces that the Copilot desktop app
+//! (`github/github-app`) and the Copilot CLI (`github/copilot-agent-runtime`)
+//! would otherwise each re-implement. It is deliberately lightweight — no
+//! `build.rs`, and its only dependencies are the Windows-only `windows` /
+//! `windows-core` crates — so a napi addon or Tauri backend can depend on it
+//! without pulling the full `github-copilot-sdk` client. The client crate
+//! re-exports it as `github_copilot_sdk::shell_tasks` behind its `shell-tasks`
+//! feature.
+//!
+//! - `contract` — the pure-`std`, FFI-free cross-process contract for the
+//!   hover-card round-trip (named-pipe name, focus sidecar file name, and the
+//!   sidecar payload format). Compiles and unit-tests on every platform.
+//! - `content` — the data-driven `AppTaskContent` builder: a neutral
+//!   `ContentSpec` plus a `#[cfg(windows)]` `build_content` that reproduces the
+//!   identical WinRT call sequence both products otherwise hand-roll.
+//! - `sparse` — the napi-free sparse (external-location) package registrar that
+//!   grants an unpackaged exe a Windows package identity (required by the
+//!   presence API), including the process-lifetime MTA keepalive. Windows-only
+//!   routines; neutral result types compile everywhere.
+//! - `bindings` — the vendored WinRT projection of the `AppTaskContract`,
+//!   re-exported as `Windows`. Windows-only; see below.
+//!
+//! The WinRT-touching code (`content`'s builder, `sparse`'s registrar, and the
+//! `bindings` projection) is `#[cfg(windows)]` and pulls the `windows` /
+//! `windows-core` crates only on Windows (they are declared under
+//! `[target.'cfg(windows)'.dependencies]`), so the crate still compiles as a
+//! lean, pure-`std` no-op on every other platform.
+#![warn(missing_docs)]
+#![deny(rustdoc::broken_intra_doc_links)]
+#![cfg_attr(test, allow(clippy::unwrap_used))]
+
+pub mod contract;
+pub mod content;
+pub mod sparse;
+
+// Vendored, machine-generated WinRT projection: it has no doc comments and is
+// never hand-edited, so `missing_docs` (a crate-level `warn`) is allowed here to
+// keep `bindings.rs` byte-for-byte verbatim (regenerate per the command at the
+// top of that file). It is Windows-only because the projected types resolve to
+// the `windows` crate's `Windows.Foundation.*` surface.
+#[cfg(windows)]
+#[allow(missing_docs)]
+mod bindings;
+
+/// The projected `Windows.UI.Shell.Tasks` namespace (`AppTaskContent`,
+/// `AppTaskInfo`, `AppTaskResultAsset`, `AppTaskManager`, and their enums).
+/// Present only on Windows (with the `shell-tasks` feature enabled).
+#[cfg(windows)]
+pub use bindings::Windows;
+
+/// Re-export of the exact `windows` crate this crate is built against.
+///
+/// A consumer (e.g. the desktop app's Tauri backend) that adopts this crate as
+/// an isolated WinRT "island" must funnel **all** of its `Windows.UI.Shell.Tasks`
+/// call-sites — including the non-`Tasks` WinRT types those call-sites touch
+/// (`Foundation::Uri`, `ApplicationModel::Package`, `Win32::System::Com`, …) —
+/// through *this* re-export rather than declaring its own `windows` dependency.
+/// That guarantees every value handed to the projected `Windows.UI.Shell.Tasks`
+/// types comes from the same `windows` version the projection was generated
+/// against, so a consumer pinned to an older `windows` for the rest of its graph
+/// (Tauri/wry) can still drive the presence API without a version conflict.
+#[cfg(windows)]
+pub use ::windows;
+
+/// Re-export of the exact `windows-core` crate this crate is built against
+/// (source of `HSTRING`, `Result`, `Interface`, …). See [`windows`] for why a
+/// WinRT-island consumer must route its core types through this re-export.
+#[cfg(windows)]
+pub use ::windows_core;
diff --git a/rust/crates/github-copilot-shell-tasks/src/sparse.rs b/rust/crates/github-copilot-shell-tasks/src/sparse.rs
new file mode 100644
index 000000000..e82d4ef66
--- /dev/null
+++ b/rust/crates/github-copilot-shell-tasks/src/sparse.rs
@@ -0,0 +1,275 @@
+//! Shared, napi-free helpers for granting an *unpackaged* executable a Windows
+//! **package identity** through a *sparse* (external-location) package.
+//!
+//! The taskbar-presence API (`Windows.UI.Shell.Tasks`) only works for a process
+//! that has package identity, because it derives its per-package `tasks.json`
+//! path from `GetCurrentPackageFamilyName()`. Both the Copilot CLI and the
+//! desktop app grant that identity by registering a *sparse* package: a manifest
+//! registered against the external directory that already contains the exe (via
+//! `PackageManager::AddPackageByUriAsync` + `AddPackageOptions::ExternalLocationUri`),
+//! with no files copied into a package root.
+//!
+//! This module factors out the registration routine — including the hard-won
+//! process-lifetime MTA keepalive — as **plain, synchronous Rust** with no napi
+//! or Tauri coupling, so each product can wrap it in its own async surface (the
+//! CLI in a napi `AsyncTask`, the app in a `spawn_blocking` / Tauri command).
+//!
+//! Everything that actually touches WinRT is `#[cfg(windows)]`. The neutral
+//! result types ([`RegisterOutcome`], [`SparseError`]) are cross-platform so
+//! callers can name them on any target.
+//!
+//! # What stays product-specific
+//!
+//! The `AppxManifest.xml` itself is *not* shared — each product ships its own
+//! (different identity, logos, applications, activation schemes). Nor is the
+//! *trigger*: the CLI self-provisions in-process at launch, while the app
+//! historically registers at install time from its installer. This module only
+//! owns the register/deregister/identity-detect logic that is identical
+//! regardless of who ships the manifest or decides when to run it.
+
+use std::fmt;
+
+/// Outcome of a successful sparse-package registration attempt.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RegisterOutcome {
+    /// The manifest was registered, or an identical registration was already in
+    /// place. The caller may treat the exe as identity-carrying (after any
+    /// relaunch its activation model requires).
+    Registered,
+    /// A package with this identity is already registered and currently running
+    /// in another session (`ERROR_PACKAGES_IN_USE`, `0x80073D02`). Registration
+    /// was intentionally a best-effort no-op — forcing it would terminate the
+    /// other session and lose its work. This does **not** prove the live
+    /// registration matches what was requested, so callers should leave any
+    /// provisioning marker unadvanced and retry on a later launch rather than
+    /// relaunch through a possibly-stale alias.
+    InUse,
+}
+
+/// A sparse-package operation failure, carrying the flattened WinRT/deployment
+/// error text for logging. Registration is best-effort in both products: a
+/// failure never blocks startup, it is logged and the feature degrades.
+#[derive(Debug, Clone)]
+pub struct SparseError(pub String);
+
+impl fmt::Display for SparseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+impl std::error::Error for SparseError {}
+
+#[cfg(windows)]
+mod imp {
+    use std::sync::Once;
+    use std::thread;
+
+    use windows::ApplicationModel::Package;
+    use windows::Foundation::Uri;
+    use windows::Management::Deployment::{AddPackageOptions, PackageManager};
+    use windows::Win32::System::Com::{
+        COINIT_MULTITHREADED, CoIncrementMTAUsage, CoInitializeEx, CoUninitialize,
+    };
+    use windows_core::HSTRING;
+
+    use super::{RegisterOutcome, SparseError};
+
+    /// `ERROR_PACKAGES_IN_USE` — a package with this identity is registered and
+    /// currently running, so deployment could not apply this manifest/external
+    /// location without force-killing that session.
+    const ERROR_PACKAGES_IN_USE: i32 = 0x80073D02u32 as i32;
+
+    /// Ensures an implicit multithreaded apartment (MTA) is kept alive for the
+    /// entire process lifetime.
+    ///
+    /// `windows-rs` caches WinRT activation factories (e.g. the one behind
+    /// `Package::Current()`) in process-global statics the first time they are
+    /// used. Those cached pointers are only valid while the MTA that created
+    /// them stays alive. Because `run_on_mta_thread` spawns a *fresh* thread
+    /// per call that `CoInitializeEx(MTA)`s and `CoUninitialize`s, the MTA can
+    /// be torn down between calls once the last participating thread exits —
+    /// leaving the cached factory pointers dangling. A subsequent call then
+    /// dereferences freed memory inside `Package::Current()` and faults with
+    /// `0xC0000005` (access violation).
+    ///
+    /// `CoIncrementMTAUsage` registers an implicit MTA that persists
+    /// independently of any specific thread, so the apartment (and the cached
+    /// factories) survive for the process lifetime. The returned cookie is
+    /// intentionally leaked: the MTA must never be torn down while cached
+    /// factories may still be used, so we never call `CoDecrementMTAUsage`.
+    pub fn ensure_process_mta() {
+        static MTA_KEEPALIVE: Once = Once::new();
+        MTA_KEEPALIVE.call_once(|| {
+            // SAFETY: `CoIncrementMTAUsage` is callable from any thread. The
+            // increment persists for the process regardless of the returned
+            // cookie; we deliberately discard the cookie so nothing ever calls
+            // `CoDecrementMTAUsage`, keeping the implicit MTA (and the cached
+            // WinRT factories) alive for the process lifetime.
+            unsafe {
+                let _ = CoIncrementMTAUsage();
+            }
+        });
+    }
+
+    /// Runs `f` on a dedicated MTA thread and returns its result. WinRT
+    /// deployment APIs require a COM-initialized thread; spawning a fresh one
+    /// per call keeps the apartment state isolated and torn down cleanly.
+    fn run_on_mta_thread<T, F>(f: F) -> Result<T, SparseError>
+    where
+        T: Send + 'static,
+        F: FnOnce() -> Result<T, SparseError> + Send + 'static,
+    {
+        // Keep the MTA alive for the whole process so windows-rs's globally
+        // cached activation factories (e.g. behind `Package::Current()`) never
+        // dangle when this per-call thread later tears its own apartment down.
+        // See `ensure_process_mta` for the full rationale.
+        ensure_process_mta();
+
+        thread::Builder::new()
+            .name("copilot-sparse-com".to_owned())
+            .spawn(move || {
+                // SAFETY: CoInitializeEx is safe from any thread; a NULL
+                // reserved pointer with the MTA flag is the documented
+                // contract. Paired with CoUninitialize before the thread exits.
+                unsafe {
+                    let hr = CoInitializeEx(None, COINIT_MULTITHREADED);
+                    let result = f();
+                    // Only uninitialize when this call actually initialized the
+                    // apartment (S_OK/S_FALSE are both success; RPC_E_CHANGED_MODE
+                    // means someone else set the apartment first and we must not
+                    // balance it).
+                    if hr.is_ok() {
+                        CoUninitialize();
+                    }
+                    result
+                }
+            })
+            .map_err(|e| SparseError(format!("failed to spawn COM thread: {e}")))?
+            .join()
+            .map_err(|_| SparseError("COM thread panicked".to_owned()))?
+    }
+
+    /// Maps a WinRT `Result` into this module's `Result`, flattening the
+    /// HRESULT into text.
+    fn winrt<T>(value: windows_core::Result<T>) -> Result<T, SparseError> {
+        value.map_err(|e| SparseError(format!("WinRT error: {e}")))
+    }
+
+    /// Returns the current process's Package Family Name if it runs with package
+    /// identity, or `None` when it does not (the common unpackaged case). Never
+    /// errors for the no-identity case — that is a normal, expected result.
+    pub fn current_package_family_name() -> Option<String> {
+        // Run on the MTA thread for parity with the other operations and so the
+        // cached `Package` factory is created under the kept-alive apartment.
+        run_on_mta_thread(|| {
+            // `Package::Current()` fails with a well-known error when the
+            // process has no identity; treat any failure as "no identity"
+            // rather than a hard error so callers can branch on `None`.
+            let name = match Package::Current() {
+                Ok(package) => match package.Id().and_then(|id| id.FamilyName()) {
+                    Ok(name) => Some(name.to_string()),
+                    Err(_) => None,
+                },
+                Err(_) => None,
+            };
+            Ok(name)
+        })
+        .unwrap_or(None)
+    }
+
+    /// Registers the sparse package described by `manifest_uri` (a `file:///`
+    /// URI to `AppxManifest.xml` or a signed sparse `.msix`) against
+    /// `external_location` (the install directory containing the exe).
+    ///
+    /// Returns [`RegisterOutcome::Registered`] on a successful (or already
+    /// applied) deployment, or [`RegisterOutcome::InUse`] when the identity is
+    /// held by another running session (see that variant's docs). This blocks
+    /// the calling thread until deployment completes; wrap it in your product's
+    /// async surface.
+    pub fn register_sparse_package(
+        manifest_uri: &str,
+        external_location: &str,
+    ) -> Result<RegisterOutcome, SparseError> {
+        let manifest_uri = manifest_uri.to_owned();
+        let external_location = external_location.to_owned();
+        run_on_mta_thread(move || {
+            let manager = winrt(PackageManager::new())?;
+            let package_uri = winrt(Uri::CreateUri(&HSTRING::from(&manifest_uri)))?;
+            let external_uri = winrt(Uri::CreateUri(&HSTRING::from(&external_location)))?;
+
+            let options = winrt(AddPackageOptions::new())?;
+            winrt(options.SetExternalLocationUri(&external_uri))?;
+            // Intentionally leave ForceAppShutdown at its default `false`.
+            // Forcing a shutdown would terminate every other running process of
+            // this package — i.e. other identity-launched sessions — and lose
+            // their in-progress work. A re-registration that collides with a
+            // running instance is handled below as a best-effort no-op instead.
+
+            let operation = winrt(manager.AddPackageByUriAsync(&package_uri, &options))?;
+            // Block this dedicated MTA thread until deployment completes.
+            let result = winrt(operation.join())?;
+
+            // A non-S_OK extended error code indicates a deployment failure.
+            let error_code = winrt(result.ExtendedErrorCode())?;
+            if error_code.is_err() {
+                // ERROR_PACKAGES_IN_USE: report as incomplete rather than
+                // success so the caller retries later instead of relaunching
+                // through a possibly-stale alias. See RegisterOutcome::InUse.
+                if error_code.0 == ERROR_PACKAGES_IN_USE {
+                    return Ok(RegisterOutcome::InUse);
+                }
+                let text = result.ErrorText().map(|t| t.to_string()).unwrap_or_default();
+                return Err(SparseError(format!(
+                    "sparse package registration failed ({error_code:?}): {text}"
+                )));
+            }
+            Ok(RegisterOutcome::Registered)
+        })
+    }
+
+    /// Deregisters the sparse package identified by its full package name.
+    /// Returns `true` on success. Blocks until deployment completes.
+    pub fn deregister_sparse_package(package_full_name: &str) -> Result<bool, SparseError> {
+        let package_full_name = package_full_name.to_owned();
+        run_on_mta_thread(move || {
+            let manager = winrt(PackageManager::new())?;
+            let operation = winrt(manager.RemovePackageAsync(&HSTRING::from(&package_full_name)))?;
+            let result = winrt(operation.join())?;
+            let error_code = winrt(result.ExtendedErrorCode())?;
+            if error_code.is_err() {
+                let text = result.ErrorText().map(|t| t.to_string()).unwrap_or_default();
+                return Err(SparseError(format!(
+                    "sparse package deregistration failed ({error_code:?}): {text}"
+                )));
+            }
+            Ok(true)
+        })
+    }
+}
+
+#[cfg(windows)]
+pub use imp::{
+    current_package_family_name, deregister_sparse_package, ensure_process_mta,
+    register_sparse_package,
+};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sparse_error_displays_its_message() {
+        let err = SparseError("deployment 0x80073CF9".to_owned());
+        assert_eq!(err.to_string(), "deployment 0x80073CF9");
+        // Exercised via the `std::error::Error` object-safe path too.
+        let dyn_err: &dyn std::error::Error = &err;
+        assert_eq!(dyn_err.to_string(), "deployment 0x80073CF9");
+    }
+
+    #[test]
+    fn register_outcome_variants_are_distinct() {
+        assert_ne!(RegisterOutcome::Registered, RegisterOutcome::InUse);
+        assert_eq!(RegisterOutcome::Registered, RegisterOutcome::Registered);
+    }
+}
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index f998d7225..1d108d55e 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -71,6 +71,13 @@ pub(crate) mod generated;
 /// source-qualified tool filter patterns.
 pub mod mode;
 
+/// Shared integration with the experimental `Windows.UI.Shell.Tasks`
+/// ("Forerunner" / taskbar presence) API, re-exported from the standalone
+/// `github-copilot-shell-tasks` crate. Off by default; enable the
+/// `shell-tasks` feature.
+#[cfg(feature = "shell-tasks")]
+pub use github_copilot_shell_tasks as shell_tasks;
+
 use std::ffi::OsString;
 use std::path::{Path, PathBuf};
 use std::process::Stdio;