pi-teams 0.8.6 → 0.9.0

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/extensions/index.ts

@@ -5,6 +5,7 @@ import * as paths from "../src/utils/paths";
 import * as teams from "../src/utils/teams";
 import * as tasks from "../src/utils/tasks";
 import * as messaging from "../src/utils/messaging";
+import * as runtime from "../src/utils/runtime";
 import { Member } from "../src/utils/models";
 import { getTerminalAdapter } from "../src/adapters/terminal-registry";
 import { Iterm2Adapter } from "../src/adapters/iterm2-adapter";
@@ -154,6 +155,13 @@ export default function (pi: ExtensionAPI) {
       if (teamName) {
         const pidFile = path.join(paths.teamDir(teamName), `${agentName}.pid`);
         fs.writeFileSync(pidFile, process.pid.toString());
+        await runtime.writeRuntimeStatus(teamName, agentName, {
+          pid: process.pid,
+          startedAt: Date.now(),
+          lastHeartbeatAt: Date.now(),
+          ready: false,
+          lastError: undefined,
+        });
       }
       ctx.ui.notify(`Teammate: ${agentName} (Team: ${teamName})`, "info");
       ctx.ui.setStatus("00-pi-teams", `[${agentName.toUpperCase()}]`);
@@ -176,9 +184,19 @@ export default function (pi: ExtensionAPI) {
 
       setInterval(async () => {
         if (ctx.isIdle() && teamName) {
-          const unread = await messaging.readInbox(teamName, agentName, true, false);
-          if (unread.length > 0) {
-            pi.sendUserMessage(`I have ${unread.length} new message(s) in my inbox. Reading them now...`);
+          try {
+            const unread = await messaging.readInbox(teamName, agentName, true, false);
+            await runtime.writeRuntimeStatus(teamName, agentName, {
+              lastHeartbeatAt: Date.now(),
+            });
+            if (unread.length > 0) {
+              pi.sendUserMessage(`I have ${unread.length} new message(s) in my inbox. Reading them now...`);
+            }
+          } catch (e) {
+            await runtime.writeRuntimeStatus(teamName, agentName, {
+              lastHeartbeatAt: Date.now(),
+              lastError: runtime.createRuntimeError(e),
+            });
           }
         }
       }, 30000);
@@ -192,6 +210,11 @@ export default function (pi: ExtensionAPI) {
       const fullTitle = teamName ? `${teamName}: ${agentName}` : agentName;
       if ((ctx.ui as any).setTitle) (ctx.ui as any).setTitle(fullTitle);
       if (terminal) terminal.setTitle(fullTitle);
+      if (teamName) {
+        await runtime.writeRuntimeStatus(teamName, agentName, {
+          lastHeartbeatAt: Date.now(),
+        });
+      }
     }
   });
 
@@ -200,6 +223,12 @@ export default function (pi: ExtensionAPI) {
     if (isTeammate && firstTurn) {
       firstTurn = false;
 
+      if (teamName) {
+        await runtime.writeRuntimeStatus(teamName, agentName, {
+          lastHeartbeatAt: Date.now(),
+        });
+      }
+
       let modelInfo = "";
       if (teamName) {
         try {
@@ -244,6 +273,8 @@ export default function (pi: ExtensionAPI) {
     if (member.tmuxPaneId && terminal) {
       terminal.kill(member.tmuxPaneId);
     }
+
+    await runtime.deleteRuntimeStatus(teamName, member.name);
   }
 
   // Tools
@@ -480,6 +511,16 @@ export default function (pi: ExtensionAPI) {
     async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const targetAgent = params.agent_name || agentName;
       const msgs = await messaging.readInbox(params.team_name, targetAgent, params.unread_only);
+
+      if (isTeammate && teamName && params.team_name === teamName && targetAgent === agentName) {
+        await runtime.writeRuntimeStatus(teamName, agentName, {
+          lastHeartbeatAt: Date.now(),
+          lastInboxReadAt: Date.now(),
+          ready: true,
+          lastError: undefined,
+        });
+      }
+
       return {
         content: [{ type: "text", text: JSON.stringify(msgs, null, 2) }],
         details: { messages: msgs },
@@ -643,9 +684,40 @@ export default function (pi: ExtensionAPI) {
       }
 
       const unreadCount = (await messaging.readInbox(params.team_name, params.agent_name, true, false)).length;
+      const runtimeStatus = await runtime.readRuntimeStatus(params.team_name, params.agent_name);
+      const now = Date.now();
+      const hasRecentHeartbeat = !!runtimeStatus?.lastHeartbeatAt
+        && (now - runtimeStatus.lastHeartbeatAt) <= runtime.HEARTBEAT_STALE_MS;
+      const startupStalled = alive
+        && unreadCount > 0
+        && (now - member.joinedAt) > runtime.STARTUP_STALL_MS
+        && !(runtimeStatus?.ready);
+      const health = !alive
+        ? "dead"
+        : startupStalled
+          ? "stalled"
+          : runtimeStatus?.ready
+            ? (hasRecentHeartbeat ? "healthy" : "idle")
+            : "starting";
+
+      const details = {
+        alive,
+        unreadCount,
+        health,
+        agentLoopReady: !!runtimeStatus?.ready,
+        hasRecentHeartbeat,
+        startupStalled,
+        runtime: runtimeStatus,
+      };
+
+      // Clean up runtime status for dead teammates
+      if (!alive && runtimeStatus) {
+        await runtime.deleteRuntimeStatus(params.team_name, params.agent_name);
+      }
+
       return {
-        content: [{ type: "text", text: JSON.stringify({ alive, unreadCount }, null, 2) }],
-        details: { alive, unreadCount },
+        content: [{ type: "text", text: JSON.stringify(details, null, 2) }],
+        details,
       };
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-teams",
-  "version": "0.8.6",
+  "version": "0.9.0",
   "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) {