diff --git a/packages/plugins/notifier-desktop/src/index.test.ts b/packages/plugins/notifier-desktop/src/index.test.ts
index ed2b80709..6abf9bae1 100644
--- a/packages/plugins/notifier-desktop/src/index.test.ts
+++ b/packages/plugins/notifier-desktop/src/index.test.ts
@@ -36,11 +36,14 @@ describe("notifier-desktop", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockPlatform.mockReturnValue("darwin");
-    mockExecFile.mockImplementation(
-      (_cmd: string, _args: string[], cb: (err: Error | null) => void) => {
-        cb(null);
-      },
-    );
+    mockExecFile.mockImplementation((..._args: unknown[]) => {
+      // execFile may be called as (cmd, args, cb) or (cmd, args, opts, cb).
+      // Pick whichever trailing arg is the callback so both shapes work.
+      const cb = _args.find((a) => typeof a === "function") as
+        | ((err: Error | null) => void)
+        | undefined;
+      cb?.(null);
+    });
   });
 
   describe("manifest", () => {
@@ -220,14 +223,63 @@ describe("notifier-desktop", () => {
     });
   });
 
+  describe("notify on Windows", () => {
+    it("invokes powershell.exe with an EncodedCommand toast script", async () => {
+      mockPlatform.mockReturnValue("win32");
+      const notifier = create();
+      await notifier.notify(makeEvent({ message: "hello" }));
+
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "powershell.exe",
+        expect.arrayContaining(["-EncodedCommand"]),
+        expect.objectContaining({ windowsHide: true }),
+        expect.any(Function),
+      );
+      const args = mockExecFile.mock.calls[0][1] as string[];
+      const encoded = args[args.indexOf("-EncodedCommand") + 1];
+      const script = Buffer.from(encoded, "base64").toString("utf16le");
+      expect(script).toContain("ToastNotificationManager");
+      expect(script).toContain("hello");
+    });
+
+    it("XML-escapes title and message to prevent toast XML injection", async () => {
+      mockPlatform.mockReturnValue("win32");
+      const notifier = create();
+      await notifier.notify(makeEvent({ sessionId: "<x>", message: 'a"&b' }));
+      const args = mockExecFile.mock.calls[0][1] as string[];
+      const script = Buffer.from(
+        args[args.indexOf("-EncodedCommand") + 1],
+        "base64",
+      ).toString("utf16le");
+      expect(script).toContain("&lt;x&gt;");
+      expect(script).toContain("a&quot;&amp;b");
+      expect(script).not.toContain("<x>");
+    });
+
+    it("logs a warning but does not reject when powershell fails", async () => {
+      mockPlatform.mockReturnValue("win32");
+      mockExecFile.mockImplementationOnce((..._args: unknown[]) => {
+        const cb = _args.find((a) => typeof a === "function") as
+          | ((err: Error | null) => void)
+          | undefined;
+        cb?.(new Error("WinRT unavailable"));
+      });
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const notifier = create();
+      await expect(notifier.notify(makeEvent())).resolves.toBeUndefined();
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("WinRT unavailable"));
+      warnSpy.mockRestore();
+    });
+  });
+
   describe("notify on unsupported platform", () => {
     it("resolves without error on unsupported platform", async () => {
-      mockPlatform.mockReturnValue("win32");
+      mockPlatform.mockReturnValue("freebsd");
       const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
       const notifier = create();
       await expect(notifier.notify(makeEvent())).resolves.toBeUndefined();
       expect(mockExecFile).not.toHaveBeenCalled();
-      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("not supported on win32"));
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("not supported on freebsd"));
       warnSpy.mockRestore();
     });
   });
diff --git a/packages/plugins/notifier-desktop/src/index.ts b/packages/plugins/notifier-desktop/src/index.ts
index 3df65d21c..c29e6bb0c 100644
--- a/packages/plugins/notifier-desktop/src/index.ts
+++ b/packages/plugins/notifier-desktop/src/index.ts
@@ -9,6 +9,36 @@ import {
   type EventPriority,
 } from "@aoagents/ao-core";
 
+function xmlEscape(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function buildWindowsToastScript(title: string, message: string, sound: boolean): string {
+  // Build the toast XML — both fields are user content, so XML-escape them.
+  const safeTitle = xmlEscape(title);
+  const safeMessage = xmlEscape(message);
+  const audioNode = sound ? "" : '<audio silent="true" />';
+  const xml = `<toast>${audioNode}<visual><binding template="ToastGeneric"><text>${safeTitle}</text><text>${safeMessage}</text></binding></visual></toast>`;
+
+  // PowerShell script — uses WinRT directly (no BurntToast dep). The XML is
+  // injected as a single-quoted PS string with embedded apostrophes doubled.
+  const psSafeXml = xml.replace(/'/g, "''");
+  return [
+    "$ErrorActionPreference = 'Stop'",
+    "[void][Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime]",
+    "[void][Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime]",
+    "$xml = New-Object Windows.Data.Xml.Dom.XmlDocument",
+    `$xml.LoadXml('${psSafeXml}')`,
+    "$toast = [Windows.UI.Notifications.ToastNotification]::new($xml)",
+    "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Agent Orchestrator').Show($toast)",
+  ].join("; ");
+}
+
 export const manifest = {
   name: "desktop",
   slot: "notifier" as const,
@@ -80,6 +110,28 @@ function sendNotification(
         if (err) reject(err);
         else resolve();
       });
+    } else if (os === "win32") {
+      // WinRT toast via PowerShell — no third-party deps. Encode the script
+      // as UTF-16LE base64 so we never fight with PowerShell's argument
+      // tokenizer over quotes, special chars, or newlines in the toast XML.
+      const script = buildWindowsToastScript(title, message, options.sound);
+      const encoded = Buffer.from(script, "utf16le").toString("base64");
+      execFile(
+        "powershell.exe",
+        ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded],
+        { windowsHide: true, timeout: 10_000 },
+        (err) => {
+          if (err) {
+            // Don't crash the lifecycle on toast failures — log and resolve.
+            // Common causes: stripped-down Windows SKU without WinRT, locked
+            // group policy, or the user disabled toast notifications.
+            console.warn(
+              `[notifier-desktop] Windows toast failed: ${(err as Error).message}`,
+            );
+          }
+          resolve();
+        },
+      );
     } else {
       console.warn(`[notifier-desktop] Desktop notifications not supported on ${os}`);
       resolve();
diff --git a/packages/plugins/workspace-worktree/src/__tests__/index.test.ts b/packages/plugins/workspace-worktree/src/__tests__/index.test.ts
index fe3847c01..8dc40450b 100644
--- a/packages/plugins/workspace-worktree/src/__tests__/index.test.ts
+++ b/packages/plugins/workspace-worktree/src/__tests__/index.test.ts
@@ -15,7 +15,9 @@ vi.mock("node:child_process", () => {
 vi.mock("node:fs", () => ({
   existsSync: vi.fn(),
   lstatSync: vi.fn(),
+  statSync: vi.fn(),
   symlinkSync: vi.fn(),
+  linkSync: vi.fn(),
   cpSync: vi.fn(),
   rmSync: vi.fn(),
   mkdirSync: vi.fn(),
@@ -47,7 +49,9 @@ import * as childProcess from "node:child_process";
 import {
   existsSync,
   lstatSync,
+  statSync,
   symlinkSync,
+  linkSync,
   cpSync,
   rmSync,
   mkdirSync,
@@ -66,7 +70,9 @@ const mockExecFileAsync = (childProcess.execFile as any)[
 
 const mockExistsSync = existsSync as ReturnType<typeof vi.fn>;
 const mockLstatSync = lstatSync as ReturnType<typeof vi.fn>;
+const mockStatSync = statSync as ReturnType<typeof vi.fn>;
 const mockSymlinkSync = symlinkSync as ReturnType<typeof vi.fn>;
+const mockLinkSync = linkSync as ReturnType<typeof vi.fn>;
 const mockCpSync = cpSync as ReturnType<typeof vi.fn>;
 const mockRmSync = rmSync as ReturnType<typeof vi.fn>;
 const mockMkdirSync = mkdirSync as ReturnType<typeof vi.fn>;
@@ -986,13 +992,41 @@ describe("workspace.postCreate()", () => {
     );
   });
 
-  it("falls back to cpSync when symlinkSync fails on Windows (B19)", async () => {
+  it("falls back to junction for directories on Windows (B19)", async () => {
     const ws = create();
-    // Use workspaceInfo as-is — path check now uses sep so it works on all platforms
     const project = makeProject({ symlinks: ["node_modules"] });
 
     mockIsWindows.mockReturnValue(true);
-    mockExistsSync.mockReturnValueOnce(true); // sourcePath exists
+    mockExistsSync.mockReturnValueOnce(true);
+    mockLstatSync.mockImplementationOnce(() => {
+      throw new Error("ENOENT");
+    });
+
+    const symlinkError = Object.assign(new Error("symlink requires elevation"), { code: "EPERM" });
+    mockSymlinkSync
+      .mockImplementationOnce(() => {
+        throw symlinkError;
+      })
+      .mockImplementationOnce(() => undefined); // junction succeeds
+    mockStatSync.mockReturnValueOnce({ isDirectory: () => true });
+
+    await ws.postCreate!(workspaceInfo, project);
+
+    expect(mockSymlinkSync).toHaveBeenLastCalledWith(
+      expect.stringContaining("node_modules"),
+      expect.stringContaining("node_modules"),
+      "junction",
+    );
+    expect(mockLinkSync).not.toHaveBeenCalled();
+    expect(mockCpSync).not.toHaveBeenCalled();
+  });
+
+  it("falls back to hardlink for files on Windows (B19)", async () => {
+    const ws = create();
+    const project = makeProject({ symlinks: [".env"] });
+
+    mockIsWindows.mockReturnValue(true);
+    mockExistsSync.mockReturnValueOnce(true);
     mockLstatSync.mockImplementationOnce(() => {
       throw new Error("ENOENT");
     });
@@ -1001,6 +1035,37 @@ describe("workspace.postCreate()", () => {
     mockSymlinkSync.mockImplementationOnce(() => {
       throw symlinkError;
     });
+    mockStatSync.mockReturnValueOnce({ isDirectory: () => false });
+    mockLinkSync.mockImplementationOnce(() => undefined);
+
+    await ws.postCreate!(workspaceInfo, project);
+
+    expect(mockLinkSync).toHaveBeenCalledWith(
+      expect.stringContaining(".env"),
+      expect.stringContaining(".env"),
+    );
+    expect(mockCpSync).not.toHaveBeenCalled();
+  });
+
+  it("falls back to cpSync when junction also fails on Windows (B19)", async () => {
+    const ws = create();
+    const project = makeProject({ symlinks: ["node_modules"] });
+
+    mockIsWindows.mockReturnValue(true);
+    mockExistsSync.mockReturnValueOnce(true);
+    mockLstatSync.mockImplementationOnce(() => {
+      throw new Error("ENOENT");
+    });
+
+    const symlinkError = Object.assign(new Error("symlink requires elevation"), { code: "EPERM" });
+    mockSymlinkSync
+      .mockImplementationOnce(() => {
+        throw symlinkError;
+      })
+      .mockImplementationOnce(() => {
+        throw new Error("junction failed");
+      });
+    mockStatSync.mockReturnValueOnce({ isDirectory: () => true });
 
     await ws.postCreate!(workspaceInfo, project);
 
diff --git a/packages/plugins/workspace-worktree/src/index.ts b/packages/plugins/workspace-worktree/src/index.ts
index 9dc7ffd7e..88f7f834d 100644
--- a/packages/plugins/workspace-worktree/src/index.ts
+++ b/packages/plugins/workspace-worktree/src/index.ts
@@ -1,7 +1,16 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import * as fs from "node:fs";
-import { existsSync, lstatSync, symlinkSync, rmSync, mkdirSync, readdirSync } from "node:fs";
+import {
+  existsSync,
+  lstatSync,
+  statSync,
+  symlinkSync,
+  linkSync,
+  rmSync,
+  mkdirSync,
+  readdirSync,
+} from "node:fs";
 import { join, resolve, basename, dirname, sep } from "node:path";
 import { homedir } from "node:os";
 import {
@@ -410,8 +419,26 @@ export function create(config?: Record<string, unknown>): Workspace {
             symlinkSync(sourcePath, targetPath);
           } catch (err) {
             if (isWindows()) {
-              // Symlinks require admin/Developer Mode on Windows — fall back to copy
-              fs.cpSync(sourcePath, targetPath, { recursive: true });
+              // Symlinks need admin/Developer Mode on Windows. Try unprivileged
+              // alternatives first — junctions for dirs, hardlinks for files —
+              // before falling back to a recursive copy (slow + bloats every
+              // worktree, especially for node_modules).
+              const isDir = (() => {
+                try {
+                  return statSync(sourcePath).isDirectory();
+                } catch {
+                  return false;
+                }
+              })();
+              try {
+                if (isDir) {
+                  symlinkSync(sourcePath, targetPath, "junction");
+                } else {
+                  linkSync(sourcePath, targetPath);
+                }
+              } catch {
+                fs.cpSync(sourcePath, targetPath, { recursive: true });
+              }
             } else {
               throw err;
             }
diff --git a/packages/web/src/components/DirectTerminal.tsx b/packages/web/src/components/DirectTerminal.tsx
index 3d62d3630..0a6f35aa1 100644
--- a/packages/web/src/components/DirectTerminal.tsx
+++ b/packages/web/src/components/DirectTerminal.tsx
@@ -417,6 +417,31 @@ export function DirectTerminal({
           resizeObserver.observe(terminalRef.current);
         }
 
+        // Re-fit on devicePixelRatio changes (Windows display scaling, dragging
+        // window between monitors with different DPI). ResizeObserver doesn't
+        // fire for DPR-only changes, so we listen via matchMedia. Without this,
+        // moving the window to a 125%/150%-scaled monitor leaves a stripe of
+        // unrendered background to the right of the last column.
+        let dprMedia: MediaQueryList | null = null;
+        const handleDprChange = () => {
+          if (!mounted || !fitAddon.current || !terminalInstance.current) return;
+          try {
+            terminalInstance.current.clearTextureAtlas?.();
+            fitAddon.current.fit();
+            resizeTerminalMux(
+              sessionId,
+              terminalInstance.current.cols,
+              terminalInstance.current.rows,
+            );
+          } catch {
+            // Ignore fit errors
+          }
+        };
+        if (typeof window !== "undefined" && typeof window.matchMedia === "function") {
+          dprMedia = window.matchMedia(`(resolution: ${window.devicePixelRatio}dppx)`);
+          dprMedia.addEventListener?.("change", handleDprChange);
+        }
+
         // ── Preserve selection while terminal receives output ────────
         // xterm.js clears the selection on every terminal.write(). We
         // buffer incoming data while a selection is active so the
@@ -539,6 +564,7 @@ export function DirectTerminal({
         cleanup = () => {
           clearTimeout(deferredFitTimeout);
           resizeObserver?.disconnect();
+          dprMedia?.removeEventListener?.("change", handleDprChange);
           cleanupTouchScroll();
           selectionDisposable.dispose();
           if (safetyTimer) clearTimeout(safetyTimer);