pi-teams 0.8.6 → 0.8.7

package/README.md

@@ -1,6 +1,6 @@
 # pi-teams 🚀
 
-**pi-teams** turns your single Pi agent into a coordinated software engineering team. It allows you to spawn multiple "Teammate" agents in separate terminal panes that work autonomously, communicate with each other, and manage a shared task board—all mediated through tmux, Zellij, iTerm2, or WezTerm.
+**pi-teams** turns your single Pi agent into a coordinated software engineering team. It allows you to spawn multiple "Teammate" agents in separate terminal panes that work autonomously, communicate with each other, and manage a shared task board—all mediated through tmux, Zellij, iTerm2, WezTerm, or Windows Terminal.
 
 ### 🖥️ pi-teams in Action
 
@@ -8,7 +8,7 @@
 | :---: | :---: | :---: |
 | <a href="iTerm2.png"><img src="iTerm2.png" width="300" alt="pi-teams in iTerm2"></a> | <a href="tmux.png"><img src="tmux.png" width="300" alt="pi-teams in tmux"></a> | <a href="zellij.png"><img src="zellij.png" width="300" alt="pi-teams in Zellij"></a> |
 
-*Also works with **WezTerm** (cross-platform support)*
+*Also works with **WezTerm** and **Windows Terminal** (cross-platform support)*
 
 ## 🛠 Installation
 
@@ -115,7 +115,7 @@ Teammates in `planning` mode will use `task_submit_plan`. As the lead, review th
 
 ## 🪟 Terminal Requirements
 
-To show multiple agents on one screen, **pi-teams** requires a way to manage terminal panes. It supports **tmux**, **Zellij**, **iTerm2**, and **WezTerm**.
+To show multiple agents on one screen, **pi-teams** requires a way to manage terminal panes. It supports **tmux**, **Zellij**, **iTerm2**, **WezTerm**, and **Windows Terminal**.
 
 ### Option 1: tmux (Recommended)
 
@@ -156,6 +156,38 @@ wezterm  # Start WezTerm
 pi       # Start pi inside WezTerm
 ```
 
+### Option 5: Windows Terminal (Windows)
+
+**Windows Terminal** is the modern, feature-rich terminal emulator for Windows 10/11. It supports both **Panes** and **Separate OS Windows**.
+
+**Requirements:**
+- Windows 10 (version 19041 or later) or Windows 11
+- Windows Terminal installed (available from Microsoft Store or winget)
+- PowerShell 5.1 or later (pwsh.exe)
+
+Install Windows Terminal:
+- **Microsoft Store**: Search for "Windows Terminal" and install
+- **winget**: `winget install Microsoft.WindowsTerminal`
+- **Scoop**: `scoop install windows-terminal`
+
+Install PowerShell Core (optional but recommended):
+- **winget**: `winget install Microsoft.PowerShell`
+- **Scoop**: `scoop install powershell`
+
+How to run:
+```powershell
+# Open Windows Terminal and start pi
+wt
+pi
+```
+
+Or start pi directly from Windows Terminal with new window:
+```powershell
+wt -- pwsh -c "pi"
+```
+
+**Note:** On Windows, pi-teams uses PowerShell for command execution. Make sure `pi` is in your PATH. If you installed pi via npm and Node.js, verify both are accessible from PowerShell.
+
 ## 📜 Credits & Attribution
 
 This project is a port of the excellent [claude-code-teams-mcp](https://github.com/cs50victor/claude-code-teams-mcp) by [cs50victor](https://github.com/cs50victor).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-teams",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "Agent teams for pi, ported from claude-code-teams-mcp",
   "repository": {
     "type": "git",

package/src/adapters/cmux-adapter.ts

@@ -0,0 +1,191 @@
+/**
+ * CMUX Terminal Adapter
+ * 
+ * Implements the TerminalAdapter interface for CMUX (cmux.dev).
+ */
+
+import { TerminalAdapter, SpawnOptions, execCommand } from "../utils/terminal-adapter";
+
+export class CmuxAdapter implements TerminalAdapter {
+  readonly name = "cmux";
+
+  detect(): boolean {
+    // Check for CMUX specific environment variables
+    return !!process.env.CMUX_SOCKET_PATH || !!process.env.CMUX_WORKSPACE_ID;
+  }
+
+  spawn(options: SpawnOptions): string {
+    // We use new-split to create a new pane in CMUX.
+    // CMUX doesn't have a direct 'spawn' that returns a pane ID and runs a command 
+    // in one go while also returning the ID in a way we can easily capture for 'isAlive'.
+    // However, 'new-split' returns the new surface ID.
+    
+    // Construct the command with environment variables
+    const envPrefix = Object.entries(options.env)
+      .filter(([k]) => k.startsWith("PI_"))
+      .map(([k, v]) => `${k}=${v}`)
+      .join(" ");
+    
+    const fullCommand = envPrefix ? `env ${envPrefix} ${options.command}` : options.command;
+
+    // CMUX new-split returns "OK <UUID>"
+    const splitResult = execCommand("cmux", ["new-split", "right", "--command", fullCommand]);
+    
+    if (splitResult.status !== 0) {
+      throw new Error(`cmux new-split failed with status ${splitResult.status}: ${splitResult.stderr}`);
+    }
+
+    const output = splitResult.stdout.trim();
+    if (output.startsWith("OK ")) {
+      const surfaceId = output.substring(3).trim();
+      return surfaceId;
+    }
+
+    throw new Error(`cmux new-split returned unexpected output: ${output}`);
+  }
+
+  kill(paneId: string): void {
+    if (!paneId) return;
+    
+    try {
+      // CMUX calls them surfaces
+      execCommand("cmux", ["close-surface", "--surface", paneId]);
+    } catch {
+      // Ignore errors during kill
+    }
+  }
+
+  isAlive(paneId: string): boolean {
+    if (!paneId) return false;
+
+    try {
+      // We can use list-pane-surfaces and grep for the ID
+      // Or just 'identify' if we want to be precise, but list-pane-surfaces is safer
+      const result = execCommand("cmux", ["list-pane-surfaces"]);
+      return result.stdout.includes(paneId);
+    } catch {
+      return false;
+    }
+  }
+
+  setTitle(title: string): void {
+    try {
+      // rename-tab or rename-workspace? 
+      // Usually agents want to rename their current "tab" or "surface"
+      execCommand("cmux", ["rename-tab", title]);
+    } catch {
+      // Ignore errors
+    }
+  }
+
+  /**
+   * CMUX supports spawning separate OS windows
+   */
+  supportsWindows(): boolean {
+    return true;
+  }
+
+  /**
+   * Spawn a new separate OS window.
+   */
+  spawnWindow(options: SpawnOptions): string {
+    // CMUX new-window returns "OK <UUID>"
+    const result = execCommand("cmux", ["new-window"]);
+    
+    if (result.status !== 0) {
+      throw new Error(`cmux new-window failed with status ${result.status}: ${result.stderr}`);
+    }
+
+    const output = result.stdout.trim();
+    if (output.startsWith("OK ")) {
+      const windowId = output.substring(3).trim();
+      
+      // Now we need to run the command in this window.
+      // Usually new-window creates a default workspace/surface.
+      // We might need to find the workspace in that window.
+      
+      // For now, let's just use 'new-workspace' in that window if possible, 
+      // but CMUX commands usually target the current window unless specified.
+      // Wait a bit for the window to be ready?
+      
+      const envPrefix = Object.entries(options.env)
+        .filter(([k]) => k.startsWith("PI_"))
+        .map(([k, v]) => `${k}=${v}`)
+        .join(" ");
+      
+      const fullCommand = envPrefix ? `env ${envPrefix} ${options.command}` : options.command;
+
+      // Target the new window
+      execCommand("cmux", ["new-workspace", "--window", windowId, "--command", fullCommand]);
+
+      if (options.teamName) {
+        this.setWindowTitle(windowId, options.teamName);
+      }
+
+      return windowId;
+    }
+
+    throw new Error(`cmux new-window returned unexpected output: ${output}`);
+  }
+
+  /**
+   * Set the title of a specific window.
+   */
+  setWindowTitle(windowId: string, title: string): void {
+    try {
+      execCommand("cmux", ["rename-window", "--window", windowId, title]);
+    } catch {
+      // Ignore
+    }
+  }
+
+  /**
+   * Kill/terminate a window.
+   */
+  killWindow(windowId: string): void {
+    if (!windowId) return;
+    try {
+      execCommand("cmux", ["close-window", "--window", windowId]);
+    } catch {
+      // Ignore
+    }
+  }
+
+  /**
+   * Check if a window is still alive.
+   */
+  isWindowAlive(windowId: string): boolean {
+    if (!windowId) return false;
+    try {
+      const result = execCommand("cmux", ["list-windows"]);
+      return result.stdout.includes(windowId);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Custom CMUX capability: create a workspace for a problem.
+   * This isn't part of the TerminalAdapter interface but can be used via the adapter.
+   */
+  createProblemWorkspace(title: string, command?: string): string {
+    const args = ["new-workspace"];
+    if (command) {
+      args.push("--command", command);
+    }
+    
+    const result = execCommand("cmux", args);
+    if (result.status !== 0) {
+      throw new Error(`cmux new-workspace failed: ${result.stderr}`);
+    }
+    
+    const output = result.stdout.trim();
+    if (output.startsWith("OK ")) {
+      const workspaceId = output.substring(3).trim();
+      execCommand("cmux", ["workspace-action", "--action", "rename", "--title", title, "--workspace", workspaceId]);
+      return workspaceId;
+    }
+    
+    throw new Error(`cmux new-workspace returned unexpected output: ${output}`);
+  }
+}

package/src/adapters/terminal-registry.ts

@@ -1,6 +1,6 @@
 /**
  * Terminal Registry
- * 
+ *
  * Manages terminal adapters and provides automatic selection based on
  * the current environment.
  */
@@ -10,6 +10,7 @@ import { TmuxAdapter } from "./tmux-adapter";
 import { Iterm2Adapter } from "./iterm2-adapter";
 import { ZellijAdapter } from "./zellij-adapter";
 import { WezTermAdapter } from "./wezterm-adapter";
+import { WindowsAdapter } from "./windows-adapter";
 
 /**
  * Available terminal adapters, ordered by priority
@@ -19,12 +20,14 @@ import { WezTermAdapter } from "./wezterm-adapter";
  * 2. Zellij - if ZELLIJ env is set and not in tmux
  * 3. iTerm2 - if TERM_PROGRAM=iTerm.app and not in tmux/zellij
  * 4. WezTerm - if WEZTERM_PANE env is set and not in tmux/zellij
+ * 5. Windows - if platform is win32 and not in tmux/zellij/iTerm2/WezTerm
  */
 const adapters: TerminalAdapter[] = [
   new TmuxAdapter(),
   new ZellijAdapter(),
   new Iterm2Adapter(),
   new WezTermAdapter(),
+  new WindowsAdapter(),
 ];
 
 /**
@@ -40,6 +43,7 @@ let cachedAdapter: TerminalAdapter | null = null;
  * 2. Zellij - if ZELLIJ env is set and not in tmux
  * 3. iTerm2 - if TERM_PROGRAM=iTerm.app and not in tmux/zellij
  * 4. WezTerm - if WEZTERM_PANE env is set and not in tmux/zellij
+ * 5. Windows - if platform is win32 and not in tmux/zellij/iTerm2/WezTerm
  *
  * @returns The detected terminal adapter, or null if none detected
  */
@@ -61,7 +65,7 @@ export function getTerminalAdapter(): TerminalAdapter | null {
 /**
  * Get a specific terminal adapter by name.
  *
- * @param name - The adapter name (e.g., "tmux", "iTerm2", "zellij", "WezTerm")
+ * @param name - The adapter name (e.g., "tmux", "iTerm2", "zellij", "WezTerm", "Windows")
  * @returns The adapter instance, or undefined if not found
  */
 export function getAdapterByName(name: string): TerminalAdapter | undefined {
@@ -70,7 +74,7 @@ export function getAdapterByName(name: string): TerminalAdapter | undefined {
 
 /**
  * Get all available adapters.
- * 
+ *
  * @returns Array of all registered adapters
  */
 export function getAllAdapters(): TerminalAdapter[] {
@@ -93,7 +97,7 @@ export function setAdapter(adapter: TerminalAdapter): void {
 
 /**
  * Check if any terminal adapter is available.
- * 
+ *
  * @returns true if a terminal adapter was detected
  */
 export function hasTerminalAdapter(): boolean {
@@ -102,8 +106,8 @@ export function hasTerminalAdapter(): boolean {
 
 /**
  * Check if the current terminal supports spawning separate OS windows.
- * 
- * @returns true if the detected terminal supports windows (iTerm2, WezTerm)
+ *
+ * @returns true if the detected terminal supports windows (iTerm2, WezTerm, Windows)
  */
 export function supportsWindows(): boolean {
   const adapter = getTerminalAdapter();
@@ -112,9 +116,9 @@ export function supportsWindows(): boolean {
 
 /**
  * Get the name of the currently detected terminal adapter.
- * 
+ *
  * @returns The adapter name, or null if none detected
  */
 export function getTerminalName(): string | null {
   return getTerminalAdapter()?.name ?? null;
-}
+}

package/src/adapters/wezterm-adapter.ts

@@ -73,6 +73,22 @@ export class WezTermAdapter implements TerminalAdapter {
     }
   }
 
+  /**
+   * Build command arguments for the current platform.
+   * On Windows, uses PowerShell. On Unix, uses sh.
+   */
+  private buildCommandArgs(options: SpawnOptions, envArgs: string[]): string[] {
+    if (process.platform === "win32") {
+      // Windows: Use PowerShell
+      // Build the command without environment variables (they'll be set via WezTerm's env)
+      const psCommand = `cd '${options.cwd}'; ${options.command}`;
+      return ["pwsh", "-NoExit", "-Command", psCommand];
+    } else {
+      // Unix: Use sh
+      return ["env", ...envArgs, "sh", "-c", options.command];
+    }
+  }
+
   spawn(options: SpawnOptions): string {
     const weztermBin = this.findWeztermBinary();
     if (!weztermBin) {
@@ -80,40 +96,66 @@ export class WezTermAdapter implements TerminalAdapter {
     }
 
     const panes = this.getPanes();
-    const envArgs = Object.entries(options.env)
-      .filter(([k]) => k.startsWith("PI_"))
-      .map(([k, v]) => `${k}=${v}`);
-
-    let weztermArgs: string[];
     
     // First pane: split to the right with 50% (matches iTerm2/tmux behavior)
     const isFirstPane = panes.length === 1;
 
-    if (isFirstPane) {
-      weztermArgs = [
-        "cli", "split-pane", "--right", "--percent", "50",
-        "--cwd", options.cwd, "--", "env", ...envArgs, "sh", "-c", options.command
-      ];
+    let weztermArgs: string[];
+
+    if (process.platform === "win32") {
+      // Windows: Use PowerShell with double quotes (works when WezTerm wraps in single quotes)
+      const envVars = Object.entries(options.env)
+        .filter(([k]) => k.startsWith("PI_"))
+        .map(([k, v]) => `$env:${k}="${v}"`)
+        .join("; ");
+      
+      const psCommand = `${envVars}; cd "${options.cwd}"; ${options.command}`;
+      // Use 'powershell' (built-in) instead of 'pwsh' (PowerShell Core, may not be installed)
+      const cmdArgs = ["powershell", "-NoExit", "-Command", psCommand];
+
+      if (isFirstPane) {
+        weztermArgs = [
+          "cli", "split-pane", "--right", "--percent", "50",
+          "--cwd", options.cwd, "--", ...cmdArgs
+        ];
+      } else {
+        const currentPaneId = parseInt(process.env.WEZTERM_PANE || "0", 10);
+        const sidebarPanes = panes
+          .filter(p => p.pane_id !== currentPaneId)
+          .sort((a, b) => b.cursor_y - a.cursor_y);
+        const targetPane = sidebarPanes[0];
+
+        weztermArgs = [
+          "cli", "split-pane", "--bottom", "--pane-id", targetPane.pane_id.toString(),
+          "--percent", "50",
+          "--cwd", options.cwd, "--", ...cmdArgs
+        ];
+      }
     } else {
-      // Subsequent teammates stack in the sidebar on the right.
-      // currentPaneId (id 0) is the main pane on the left.
-      // All other panes are in the sidebar.
-      const currentPaneId = parseInt(process.env.WEZTERM_PANE || "0", 10);
-      const sidebarPanes = panes
-        .filter(p => p.pane_id !== currentPaneId)
-        .sort((a, b) => b.cursor_y - a.cursor_y); // Sort by vertical position (bottom-most first)
-
-      // To add a new pane to the bottom of the sidebar stack:
-      // We always split the BOTTOM-MOST pane (sidebarPanes[0])
-      // and use 50% so the new pane and the previous bottom pane are equal.
-      // This progressively fills the sidebar from top to bottom.
-      const targetPane = sidebarPanes[0];
-
-      weztermArgs = [
-        "cli", "split-pane", "--bottom", "--pane-id", targetPane.pane_id.toString(),
-        "--percent", "50",
-        "--cwd", options.cwd, "--", "env", ...envArgs, "sh", "-c", options.command
-      ];
+      // Unix: Use sh with env command
+      const envArgs = Object.entries(options.env)
+        .filter(([k]) => k.startsWith("PI_"))
+        .map(([k, v]) => `${k}=${v}`);
+      const cmdArgs = ["env", ...envArgs, "sh", "-c", options.command];
+
+      if (isFirstPane) {
+        weztermArgs = [
+          "cli", "split-pane", "--right", "--percent", "50",
+          "--cwd", options.cwd, "--", ...cmdArgs
+        ];
+      } else {
+        const currentPaneId = parseInt(process.env.WEZTERM_PANE || "0", 10);
+        const sidebarPanes = panes
+          .filter(p => p.pane_id !== currentPaneId)
+          .sort((a, b) => b.cursor_y - a.cursor_y);
+        const targetPane = sidebarPanes[0];
+
+        weztermArgs = [
+          "cli", "split-pane", "--bottom", "--pane-id", targetPane.pane_id.toString(),
+          "--percent", "50",
+          "--cwd", options.cwd, "--", ...cmdArgs
+        ];
+      }
     }
 
     const result = execCommand(weztermBin, weztermArgs);
@@ -181,21 +223,39 @@ export class WezTermAdapter implements TerminalAdapter {
       throw new Error("WezTerm CLI binary not found.");
     }
 
-    const envArgs = Object.entries(options.env)
-      .filter(([k]) => k.startsWith("PI_"))
-      .map(([k, v]) => `${k}=${v}`);
-
     // Format window title as "teamName: agentName" if teamName is provided
     const windowTitle = options.teamName 
       ? `${options.teamName}: ${options.name}`
       : options.name;
 
-    // Spawn a new window
-    const spawnArgs = [
-      "cli", "spawn", "--new-window",
-      "--cwd", options.cwd,
-      "--", "env", ...envArgs, "sh", "-c", options.command
-    ];
+    let spawnArgs: string[];
+
+    if (process.platform === "win32") {
+      // Windows: Use PowerShell with double quotes (works when WezTerm wraps in single quotes)
+      const envVars = Object.entries(options.env)
+        .filter(([k]) => k.startsWith("PI_"))
+        .map(([k, v]) => `$env:${k}="${v}"`)
+        .join("; ");
+      
+      const psCommand = `${envVars}; cd "${options.cwd}"; ${options.command}`;
+      
+      spawnArgs = [
+        "cli", "spawn", "--new-window",
+        "--cwd", options.cwd,
+        "--", "powershell", "-NoExit", "-Command", psCommand
+      ];
+    } else {
+      // Unix: Use env command
+      const envArgs = Object.entries(options.env)
+        .filter(([k]) => k.startsWith("PI_"))
+        .map(([k, v]) => `${k}=${v}`);
+      
+      spawnArgs = [
+        "cli", "spawn", "--new-window",
+        "--cwd", options.cwd,
+        "--", "env", ...envArgs, "sh", "-c", options.command
+      ];
+    }
 
     const result = execCommand(weztermBin, spawnArgs);
     if (result.status !== 0) {

package/src/adapters/windows-adapter.test.ts

@@ -0,0 +1,313 @@
+/**
+ * Windows Adapter Tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { WindowsAdapter } from "./windows-adapter";
+
+// Mock process.platform for Windows tests
+const originalPlatform = process.platform;
+
+describe("WindowsAdapter", () => {
+  let adapter: WindowsAdapter;
+  let mockExecCommand: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    adapter = new WindowsAdapter();
+    vi.resetAllMocks();
+    vi.clearAllMocks();
+
+    // Save original process.platform
+    Object.defineProperty(process, "platform", {
+      value: originalPlatform,
+      writable: true,
+      configurable: true,
+    });
+  });
+
+  describe("basics", () => {
+    it("should have the correct name", () => {
+      expect(adapter.name).toBe("Windows");
+    });
+  });
+
+  describe("detect()", () => {
+    it("should detect when on Windows and wt is available", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+      delete process.env.TMUX;
+      delete process.env.ZELLIJ;
+      delete process.env.WEZTERM_PANE;
+
+      // Mock successful wt --version
+      vi.mock("../utils/terminal-adapter", async () => {
+        const actual = await vi.importActual<typeof import("../utils/terminal-adapter")>("../utils/terminal-adapter");
+        return {
+          ...actual,
+          execCommand: vi.fn().mockReturnValue({ stdout: "Windows Terminal", status: 0 }),
+        };
+      });
+
+      const { execCommand } = require("../utils/terminal-adapter");
+      // Create new adapter to use mocked execCommand
+      adapter = new WindowsAdapter();
+
+      expect(adapter.detect()).toBe(true);
+    });
+
+    it("should not detect when not on Windows", () => {
+      Object.defineProperty(process, "platform", { value: "darwin" });
+
+      expect(adapter.detect()).toBe(false);
+    });
+
+    it("should not detect when TMUX is set", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+      process.env.TMUX = "/tmp/tmux";
+
+      expect(adapter.detect()).toBe(false);
+    });
+
+    it("should not detect when ZELLIJ is set", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+      process.env.ZELLIJ = "true";
+
+      expect(adapter.detect()).toBe(false);
+    });
+
+    it("should not detect when WEZTERM_PANE is set", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+      process.env.WEZTERM_PANE = "123";
+
+      expect(adapter.detect()).toBe(false);
+    });
+  });
+
+  describe("spawn()", () => {
+    it("should spawn first pane on Windows", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+
+      vi.mock("../utils/terminal-adapter", async () => {
+        const actual = await vi.importActual<typeof import("../utils/terminal-adapter")>("../utils/terminal-adapter");
+        return {
+          ...actual,
+          execCommand: vi.fn().mockReturnValue({ stdout: "pane-id", status: 0 }),
+        };
+      });
+
+      const { execCommand } = require("../utils/terminal-adapter");
+      adapter = new WindowsAdapter();
+
+      const paneId = adapter.spawn({
+        name: "test-agent",
+        cwd: "/test/path",
+        command: "pi --model gpt-4",
+        env: { PI_TEAM_NAME: "team1", PI_AGENT_NAME: "agent1" },
+      });
+
+      expect(paneId).toMatch(/^windows_\d+_test-agent$/);
+      expect(execCommand).toHaveBeenCalledWith(
+        "wt",
+        expect.arrayContaining([
+          "split-pane",
+          "--vertical",
+          "--size", "50%",
+          "--", "pwsh", "-NoExit", "-Command",
+        ])
+      );
+    });
+
+    it("should spawn subsequent pane on Windows", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+
+      vi.mock("../utils/terminal-adapter", async () => {
+        const actual = await vi.importActual<typeof import("../utils/terminal-adapter")>("../utils/terminal-adapter");
+        return {
+          ...actual,
+          execCommand: vi.fn()
+            .mockReturnValueOnce({ stdout: "pane-id", status: 0 }) // wt --version
+            .mockReturnValueOnce({ stdout: '[{"window":1,"pane":1},{"window":1,"pane":2}]', status: 0 }) // wt list
+            .mockReturnValue({ stdout: "pane-id", status: 0 }), // split-pane
+        };
+      });
+
+      const { execCommand } = require("../utils/terminal-adapter");
+      adapter = new WindowsAdapter();
+
+      const paneId = adapter.spawn({
+        name: "test-agent",
+        cwd: "/test/path",
+        command: "pi --model gpt-4",
+        env: { PI_TEAM_NAME: "team1", PI_AGENT_NAME: "agent1" },
+      });
+
+      expect(paneId).toMatch(/^windows_\d+_test-agent$/);
+      expect(execCommand).toHaveBeenCalledWith(
+        "wt",
+        expect.arrayContaining(["split-pane", "--horizontal"])
+      );
+    });
+
+    it("should throw error when wt binary not found", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+
+      vi.mock("../utils/terminal-adapter", async () => {
+        const actual = await vi.importActual<typeof import("../utils/terminal-adapter")>("../utils/terminal-adapter");
+        return {
+          ...actual,
+          execCommand: vi.fn().mockReturnValue({ stdout: "", status: 1 }),
+        };
+      });
+
+      const { execCommand } = require("../utils/terminal-adapter");
+      adapter = new WindowsAdapter();
+
+      expect(() => adapter.spawn({
+        name: "test-agent",
+        cwd: "/test/path",
+        command: "pi",
+        env: {},
+      })).toThrow("Windows Terminal (wt) CLI binary not found");
+    });
+  });
+
+  describe("supportsWindows()", () => {
+    it("should return true when wt is available", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+
+      vi.mock("../utils/terminal-adapter", async () => {
+        const actual = await vi.importActual<typeof import("../utils/terminal-adapter")>("../utils/terminal-adapter");
+        return {
+          ...actual,
+          execCommand: vi.fn().mockReturnValue({ stdout: "version", status: 0 }),
+        };
+      });
+
+      const { execCommand } = require("../utils/terminal-adapter");
+      adapter = new WindowsAdapter();
+
+      expect(adapter.supportsWindows()).toBe(true);
+    });
+
+    it("should return false when wt not available", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+
+      vi.mock("../utils/terminal-adapter", async () => {
+        const actual = await vi.importActual<typeof import("../utils/terminal-adapter")>("../utils/terminal-adapter");
+        return {
+          ...actual,
+          execCommand: vi.fn().mockReturnValue({ stdout: "", status: 1 }),
+        };
+      });
+
+      const { execCommand } = require("../utils/terminal-adapter");
+      adapter = new WindowsAdapter();
+
+      expect(adapter.supportsWindows()).toBe(false);
+    });
+  });
+
+  describe("spawnWindow()", () => {
+    it("should spawn a new window", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+
+      vi.mock("../utils/terminal-adapter", async () => {
+        const actual = await vi.importActual<typeof import("../utils/terminal-adapter")>("../utils/terminal-adapter");
+        return {
+          ...actual,
+          execCommand: vi.fn().mockReturnValue({ stdout: "window-id", status: 0 }),
+        };
+      });
+
+      const { execCommand } = require("../utils/terminal-adapter");
+      adapter = new WindowsAdapter();
+
+      const windowId = adapter.spawnWindow({
+        name: "agent",
+        cwd: "/test",
+        command: "pi",
+        env: {},
+        teamName: "team1",
+      });
+
+      expect(windowId).toMatch(/^windows_win_\d+_agent$/);
+      expect(execCommand).toHaveBeenCalledWith(
+        "wt",
+        expect.arrayContaining([
+          "new-window",
+          "--title", "team1: agent",
+        ])
+      );
+    });
+  });
+
+  describe("kill()", () => {
+    it("should handle kill gracefully for windows pane", () => {
+      adapter.kill("windows_123_agent");
+      // Should not throw, just silently do nothing
+      expect(true).toBe(true);
+    });
+
+    it("should ignore non-windows pane IDs", () => {
+      adapter.kill("tmux_123");
+      // Should not throw, just silently do nothing
+      expect(true).toBe(true);
+    });
+  });
+
+  describe("killWindow()", () => {
+    it("should handle killWindow gracefully", () => {
+      adapter.killWindow("windows_win_123_agent");
+      // Should not throw, just silently do nothing
+      expect(true).toBe(true);
+    });
+  });
+
+  describe("isAlive()", () => {
+    it("should return true for windows pane ID", () => {
+      expect(adapter.isAlive("windows_123_agent")).toBe(true);
+    });
+
+    it("should return false for non-windows pane ID", () => {
+      expect(adapter.isAlive("tmux_123")).toBe(false);
+    });
+  });
+
+  describe("isWindowAlive()", () => {
+    it("should return true for windows window ID", () => {
+      expect(adapter.isWindowAlive("windows_win_123_agent")).toBe(true);
+    });
+
+    it("should return false for non-windows window ID", () => {
+      expect(adapter.isWindowAlive("other_123")).toBe(false);
+    });
+  });
+
+  describe("setTitle()", () => {
+    it("should set tab title gracefully", () => {
+      Object.defineProperty(process, "platform", { value: "win32" });
+
+      vi.mock("../utils/terminal-adapter", async () => {
+        const actual = await vi.importActual<typeof import("../utils/terminal-adapter")>("../utils/terminal-adapter");
+        return {
+          ...actual,
+          execCommand: vi.fn().mockReturnValue({ stdout: "", status: 0 }),
+        };
+      });
+
+      const { execCommand } = require("../utils/terminal-adapter");
+      adapter = new WindowsAdapter();
+
+      adapter.setTitle("Test Title");
+      expect(execCommand).toHaveBeenCalledWith("wt", ["set-tab-title", "Test Title"]);
+    });
+  });
+
+  describe("setWindowTitle()", () => {
+    it("should gracefully handle setWindowTitle limitation", () => {
+      adapter.setWindowTitle("windows_win_123", "Test Title");
+      // Windows Terminal limitation - titles are set at spawn time
+      // Should silently do nothing without throwing
+      expect(true).toBe(true);
+    });
+  });
+});

package/src/adapters/windows-adapter.ts

@@ -0,0 +1,269 @@
+/**
+ * Windows Terminal/PowerShell Adapter
+ *
+ * Implements the TerminalAdapter interface for Windows with PowerShell.
+ * Uses wt (Windows Terminal) CLI for pane management and PowerShell for command execution.
+ */
+
+import { TerminalAdapter, SpawnOptions, execCommand } from "../utils/terminal-adapter";
+
+export class WindowsAdapter implements TerminalAdapter {
+  readonly name = "Windows";
+
+  // Common paths where wt CLI might be found on Windows
+  private possiblePaths = [
+    "wt",  // In PATH
+    "C:\\Program Files\\WindowsApps\\Microsoft.WindowsTerminal_8wekyb3d8bbwe\\wt.exe",  // WindowsApps
+    "C:\\Users\\${process.env.USERNAME}\\AppData\\Local\\Microsoft\\WindowsApps\\wt.exe",  // User Local
+  ];
+
+  private wtPath: string | null = null;
+
+  private findWtBinary(): string | null {
+    if (this.wtPath !== null) {
+      return this.wtPath;
+    }
+
+    // On Windows, wt.exe is usually available via WindowsApps
+    // Try different methods to detect it
+    try {
+      // Method 1: Try running wt directly (works in Windows Terminal)
+      const result = execCommand("wt", ["--version"]);
+      // wt doesn't have a proper --version, but if it exists, it will fail with a specific error
+      // If it doesn't exist, spawnSync will throw
+      this.wtPath = "wt";
+      return "wt";
+    } catch {
+      // Method 2: Check common paths
+      const fs = require("fs");
+      const possiblePaths = [
+        `C:\\Users\\${process.env.USERNAME}\\AppData\\Local\\Microsoft\\WindowsApps\\wt.exe`,
+        "C:\\Program Files\\WindowsApps\\Microsoft.WindowsTerminal_8wekyb3d8bbwe\\wt.exe",
+      ];
+      
+      for (const p of possiblePaths) {
+        try {
+          if (fs.existsSync(p)) {
+            this.wtPath = p;
+            return p;
+          }
+        } catch {}
+      }
+    }
+
+    // Method 3: Just assume wt is available on Windows and let spawn fail if not
+    // This is a reasonable fallback for most Windows 10/11 systems
+    if (process.platform === "win32") {
+      this.wtPath = "wt";
+      return "wt";
+    }
+
+    this.wtPath = null;
+    return null;
+  }
+
+  detect(): boolean {
+    // Windows only - check platform
+    if (process.platform !== "win32") {
+      return false;
+    }
+
+    // Don't use if inside tmux, Zellij, or WezTerm
+    // Note: we DO detect in mintty/Git Bash because we can still use Windows Terminal
+    if (process.env.TMUX || process.env.ZELLIJ || process.env.WEZTERM_PANE) {
+      return false;
+    }
+
+    // On Windows, always try to use Windows Terminal
+    // findWtBinary() will return "wt" as fallback
+    return true;
+  }
+
+  /**
+   * Get all panes in the current window to determine layout state.
+   * wt cli list returns JSON with pane information.
+   */
+  private getPanes(): any[] {
+    const wtBin = this.findWtBinary();
+    if (!wtBin) return [];
+
+    try {
+      const result = execCommand(wtBin, ["list", "--format", "json"]);
+      if (result.status !== 0) return [];
+
+      const allPanes = JSON.parse(result.stdout);
+      
+      // Filter to get panes from current window only
+      // We can't easily get the current pane ID on Windows, so we assume
+      // the first window in the list is the current one
+      if (allPanes.length === 0) return [];
+      
+      const currentWindowId = allPanes[0].window;
+      return allPanes.filter((p: any) => p.window === currentWindowId);
+    } catch {
+      return [];
+    }
+  }
+
+  spawn(options: SpawnOptions): string {
+    const wtBin = this.findWtBinary();
+    if (!wtBin) {
+      throw new Error("Windows Terminal (wt) CLI binary not found.");
+    }
+
+    const panes = this.getPanes();
+
+    // Build environment variables for PowerShell
+    const envVars = Object.entries(options.env)
+      .filter(([k]) => k.startsWith("PI_"))
+      .map(([k, v]) => `$env:${k}='${v}'`)
+      .join(" ");
+
+    // Build the PowerShell command
+    // Use icm (Invoke-Command) to run in a specific directory with env vars
+    const psCommand = `cd '${options.cwd}'; ${envVars}; ${options.command}`;
+
+    // Use wt split-pane command
+    // First pane splits vertically (right), subsequent panes stack
+    const isFirstPane = panes.length <= 1;
+
+    let wtArgs: string[];
+
+    if (isFirstPane) {
+      wtArgs = [
+        "split-pane",
+        "--vertical",
+        "--size", "50%",
+        "--", "pwsh", "-NoExit", "-Command", psCommand
+      ];
+    } else {
+      // Create a new tab for subsequent panes (Windows Terminal limitation)
+      // Alternatively split horizontally at the bottom
+      wtArgs = [
+        "split-pane",
+        "--horizontal",
+        "--size", "50%",
+        "--", "pwsh", "-NoExit", "-Command", psCommand
+      ];
+    }
+
+    const result = execCommand(wtBin, wtArgs);
+    if (result.status !== 0) {
+      throw new Error(`Windows Terminal spawn failed: ${result.stderr}`);
+    }
+
+    // wt doesn't return a pane ID, so we create a synthetic one
+    // We'll use a timestamp + name to make it unique
+    const syntheticId = `windows_${Date.now()}_${options.name}`;
+    return syntheticId;
+  }
+
+  kill(paneId: string): void {
+    if (!paneId?.startsWith("windows_")) return;
+
+    // Windows Terminal doesn't have a direct kill-pane command via CLI
+    // The pane will close when the PowerShell process exits
+    // We could potentially kill the process if we tracked PIDs, but for now
+    // we'll just let the user close it manually or the process ends naturally
+  }
+
+  isAlive(paneId: string): boolean {
+    if (!paneId?.startsWith("windows_")) return false;
+
+    // Windows Terminal doesn't provide an easy way to check pane status via CLI
+    // We assume the pane is alive for simplicity
+    // In production, you might want to track PIDs and check process status
+    return true;
+  }
+
+  setTitle(title: string): void {
+    const wtBin = this.findWtBinary();
+    if (!wtBin) return;
+
+    try {
+      // Set tab title (Windows Terminal uses tab titles, not pane titles)
+      execCommand(wtBin, ["set-tab-title", title]);
+    } catch {
+      // Silently fail
+    }
+  }
+
+  /**
+   * Windows Terminal supports spawning separate OS windows via New Tab or New Window
+   */
+  supportsWindows(): boolean {
+    return this.findWtBinary() !== null;
+  }
+
+  /**
+   * Spawn a new separate OS window with the given options.
+   * Uses `wt new-window` or starts a new wt instance.
+   */
+  spawnWindow(options: SpawnOptions): string {
+    const wtBin = this.findWtBinary();
+    if (!wtBin) {
+      throw new Error("Windows Terminal (wt) CLI binary not found.");
+    }
+
+    // Build environment variables for PowerShell
+    const envVars = Object.entries(options.env)
+      .filter(([k]) => k.startsWith("PI_"))
+      .map(([k, v]) => `$env:${k}='${v}'`)
+      .join(" ");
+
+    // Build the PowerShell command
+    const psCommand = `cd '${options.cwd}'; ${envVars}; ${options.command}`;
+
+    // Format window title as "teamName: agentName" if teamName is provided
+    const windowTitle = options.teamName
+      ? `${options.teamName}: ${options.name}`
+      : options.name;
+
+    // Use wt new-window
+    const spawnArgs = [
+      "new-window",
+      "--title", windowTitle,
+      "--", "pwsh", "-NoExit", "-Command", psCommand
+    ];
+
+    const result = execCommand(wtBin, spawnArgs);
+    if (result.status !== 0) {
+      throw new Error(`Windows Terminal spawn-window failed: ${result.stderr}`);
+    }
+
+    // Create a synthetic window ID
+    const syntheticId = `windows_win_${Date.now()}_${options.name}`;
+    return syntheticId;
+  }
+
+  /**
+   * Set the title of a specific window.
+   */
+  setWindowTitle(windowId: string, title: string): void {
+    // Windows Terminal CLI doesn't support setting window titles post-creation
+    // Titles are set at spawn time via --title flag
+    // This is a limitation of the wt CLI
+  }
+
+  /**
+   * Kill/terminate a window.
+   */
+  killWindow(windowId: string): void {
+    if (!windowId?.startsWith("windows_win_")) return;
+
+    // Windows Terminal doesn't provide a direct way to kill windows via CLI
+    // This is a limitation of the wt CLI
+    // Users would need to close the window manually
+  }
+
+  /**
+   * Check if a window is still alive/active.
+   */
+  isWindowAlive(windowId: string): boolean {
+    if (!windowId?.startsWith("windows_win_")) return false;
+
+    // Windows Terminal doesn't provide an easy way to check window status via CLI
+    // We assume the window is alive for simplicity
+    return true;
+  }
+}