pi-teams 0.8.2 → 0.8.5

package/README.md

@@ -45,6 +45,8 @@ pi install npm:pi-teams
 - **Beautiful UI**: Optimized vertical splits in `tmux` with clear labels so you always know who is doing what.
 
 ### Advanced Features
+- **Isolated OS Windows**: Launch teammates in true separate OS windows instead of panes.
+- **Persistent Window Titles**: Windows are automatically titled `[team-name]: [agent-name]` for easy identification in your window manager.
 - **Plan Approval Mode**: Require teammates to submit their implementation plans for your approval before they touch any code.
 - **Broadcast Messaging**: Send a message to the entire team at once for global coordination and announcements.
 - **Quality Gate Hooks**: Automated shell scripts run when tasks are completed (e.g., to run tests or linting).
@@ -58,9 +60,20 @@ pi install npm:pi-teams
 **Set a default model for the whole team:**
 > **You:** "Create a team named 'Research' and use 'gpt-4o' for everyone."
 
+**Start a team in "Separate Windows" mode:**
+> **You:** "Create a team named 'Dev' and open everyone in separate windows."
+*(Supported in iTerm2 and WezTerm only)*
+
 ### 2. Spawn Teammate with Custom Settings
 > **You:** "Spawn a teammate named 'security-bot' in the current folder. Tell them to scan for hardcoded API keys."
 
+**Spawn a specific teammate in a separate window:**
+> **You:** "Spawn 'researcher' in a separate window."
+
+**Move the Team Lead to a separate window:**
+> **You:** "Open the team lead in its own window."
+*(Requires separate_windows mode enabled or iTerm2/WezTerm)*
+
 **Use a different model:**
 > **You:** "Spawn a teammate named 'speed-bot' using 'haiku' to quickly run some benchmarks."
 
@@ -111,11 +124,15 @@ Simply start `pi` inside a Zellij session. **pi-teams** will detect it via the `
 
 ### Option 3: iTerm2 (macOS)
 
-If you are using **iTerm2** on macOS and are *not* inside tmux or Zellij, **pi-teams** will use AppleScript to automatically split your current window into an optimized layout (1 large Lead pane on the left, Teammates stacked on the right). It will also name the panes with the teammate's agent name for easy identification.
+If you are using **iTerm2** on macOS and are *not* inside tmux or Zellij, **pi-teams** can manage your team in two ways:
+1. **Panes (Default)**: Automatically split your current window into an optimized layout.
+2. **Windows**: Create true separate OS windows for each agent.
+
+It will name the panes or windows with the teammate's agent name for easy identification.
 
 ### Option 4: WezTerm (macOS, Linux, Windows)
 
-**WezTerm** is a GPU-accelerated, cross-platform terminal emulator written in Rust. If you are using WezTerm and are *not* inside tmux or Zellij, **pi-teams** will use `wezterm cli split-pane` to spawn teammates in new panes with an optimized layout (1 large Lead pane on the left, Teammates stacked on the right).
+**WezTerm** is a GPU-accelerated, cross-platform terminal emulator written in Rust. Like iTerm2, it supports both **Panes** and **Separate OS Windows**.
 
 Install WezTerm:
 - **macOS**: `brew install --cask wezterm`

package/extensions/index.ts

@@ -8,15 +8,14 @@ import * as messaging from "../src/utils/messaging";
 import { Member } from "../src/utils/models";
 import { getTerminalAdapter } from "../src/adapters/terminal-registry";
 import { Iterm2Adapter } from "../src/adapters/iterm2-adapter";
-import path from "node:path";
-import fs from "node:fs";
+import * as path from "node:path";
+import * as fs from "node:fs";
 
 export default function (pi: ExtensionAPI) {
   const isTeammate = !!process.env.PI_AGENT_NAME;
   const agentName = process.env.PI_AGENT_NAME || "team-lead";
   const teamName = process.env.PI_TEAM_NAME;
 
-  // Get the terminal adapter once at startup
   const terminal = getTerminalAdapter();
 
   pi.on("session_start", async (_event, ctx) => {
@@ -27,20 +26,24 @@ export default function (pi: ExtensionAPI) {
         fs.writeFileSync(pidFile, process.pid.toString());
       }
       ctx.ui.notify(`Teammate: ${agentName} (Team: ${teamName})`, "info");
-      // Use a shorter, more prominent status at the beginning if possible
-      ctx.ui.setStatus("00-pi-teams", `[${agentName.toUpperCase()}]`); 
-      
-      // Set the terminal pane title for better visibility
+      ctx.ui.setStatus("00-pi-teams", `[${agentName.toUpperCase()}]`);
+
       if (terminal) {
-        terminal.setTitle(agentName);
+        const fullTitle = teamName ? `${teamName}: ${agentName}` : agentName;
+        const setIt = () => {
+          if ((ctx.ui as any).setTitle) (ctx.ui as any).setTitle(fullTitle);
+          terminal.setTitle(fullTitle);
+        };
+        setIt();
+        setTimeout(setIt, 500);
+        setTimeout(setIt, 2000);
+        setTimeout(setIt, 5000);
       }
-      
-      // Auto-trigger the first turn for teammates
+
       setTimeout(() => {
         pi.sendUserMessage(`I am starting my work as '${agentName}' on team '${teamName}'. Checking my inbox for instructions...`);
       }, 1000);
 
-      // Periodically check for new messages when idle
       setInterval(async () => {
         if (ctx.isIdle() && teamName) {
           const unread = await messaging.readInbox(teamName, agentName, true, false);
@@ -54,12 +57,19 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
+  pi.on("turn_start", async (_event, ctx) => {
+    if (isTeammate) {
+      const fullTitle = teamName ? `${teamName}: ${agentName}` : agentName;
+      if ((ctx.ui as any).setTitle) (ctx.ui as any).setTitle(fullTitle);
+      if (terminal) terminal.setTitle(fullTitle);
+    }
+  });
+
   let firstTurn = true;
   pi.on("before_agent_start", async (event, ctx) => {
     if (isTeammate && firstTurn) {
       firstTurn = false;
 
-      // Get the teammate's model and thinking level from team config for accurate reporting
       let modelInfo = "";
       if (teamName) {
         try {
@@ -73,7 +83,7 @@ export default function (pi: ExtensionAPI) {
             modelInfo += `. When reporting your model or thinking level, use these exact values.`;
           }
         } catch (e) {
-          // If config can't be read, that's okay - proceed without model info
+          // Ignore
         }
       }
 
@@ -93,10 +103,14 @@ export default function (pi: ExtensionAPI) {
         process.kill(parseInt(pid), "SIGKILL");
         fs.unlinkSync(pidFile);
       } catch (e) {
-        // ignore if process already dead
+        // ignore
       }
     }
 
+    if (member.windowId && terminal) {
+      terminal.killWindow(member.windowId);
+    }
+
     if (member.tmuxPaneId && terminal) {
       terminal.kill(member.tmuxPaneId);
     }
@@ -111,9 +125,10 @@ export default function (pi: ExtensionAPI) {
       team_name: Type.String(),
       description: Type.Optional(Type.String()),
       default_model: Type.Optional(Type.String()),
+      separate_windows: Type.Optional(Type.Boolean({ default: false, description: "Open teammates in separate OS windows instead of panes" })),
     }),
     async execute(toolCallId, params: any, signal, onUpdate, ctx) {
-      const config = teams.createTeam(params.team_name, "local-session", "lead-agent", params.description, params.default_model);
+      const config = teams.createTeam(params.team_name, "local-session", "lead-agent", params.description, params.default_model, params.separate_windows);
       return {
         content: [{ type: "text", text: `Team ${params.team_name} created.` }],
         details: { config },
@@ -124,7 +139,7 @@ export default function (pi: ExtensionAPI) {
   pi.registerTool({
     name: "spawn_teammate",
     label: "Spawn Teammate",
-    description: "Spawn a new teammate in a terminal pane.",
+    description: "Spawn a new teammate in a terminal pane or separate window.",
     parameters: Type.Object({
       team_name: Type.String(),
       name: Type.String(),
@@ -133,6 +148,7 @@ export default function (pi: ExtensionAPI) {
       model: Type.Optional(Type.String()),
       thinking: Type.Optional(StringEnum(["off", "minimal", "low", "medium", "high"])),
       plan_mode_required: Type.Optional(Type.Boolean({ default: false })),
+      separate_window: Type.Optional(Type.Boolean({ default: false })),
     }),
     async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const safeName = paths.sanitizeName(params.name);
@@ -143,20 +159,17 @@ export default function (pi: ExtensionAPI) {
       }
 
       if (!terminal) {
-        throw new Error("No terminal adapter detected. Ensure you're running in tmux, iTerm2, or Zellij.");
+        throw new Error("No terminal adapter detected.");
       }
 
       const teamConfig = await teams.readConfig(safeTeamName);
       let chosenModel = params.model || teamConfig.defaultModel;
 
-      // If model doesn't include provider prefix (provider/model), use the team's defaultModel or fallback
       if (chosenModel && !chosenModel.includes('/')) {
-        // Check if team has a defaultModel with a provider prefix
         if (teamConfig.defaultModel && teamConfig.defaultModel.includes('/')) {
           const [provider] = teamConfig.defaultModel.split('/');
           chosenModel = `${provider}/${chosenModel}`;
         } else {
-          // Infer provider from model name
           if (chosenModel.startsWith('glm-')) {
             chosenModel = `zai/${chosenModel}`;
           } else if (chosenModel.startsWith('claude-')) {
@@ -165,6 +178,11 @@ export default function (pi: ExtensionAPI) {
         }
       }
 
+      const useSeparateWindow = params.separate_window ?? teamConfig.separateWindows ?? false;
+      if (useSeparateWindow && !terminal.supportsWindows()) {
+        throw new Error(`Separate windows mode is not supported in ${terminal.name}.`);
+      }
+
       const member: Member = {
         agentId: `${safeName}@${safeTeamName}`,
         name: safeName,
@@ -183,14 +201,12 @@ export default function (pi: ExtensionAPI) {
       await teams.addMember(safeTeamName, member);
       await messaging.sendPlainMessage(safeTeamName, "team-lead", safeName, params.prompt, "Initial prompt");
 
-      const piBinary = process.argv[1] ? `node ${process.argv[1]}` : "pi"; // Assumed on path
+      const piBinary = process.argv[1] ? `node ${process.argv[1]}` : "pi";
       let piCmd = piBinary;
 
-      // Build model command with thinking level if specified
       if (chosenModel) {
         const [provider, ...modelParts] = chosenModel.split('/');
         const modelName = modelParts.join('/');
-
         if (params.thinking) {
           piCmd = `${piBinary} --provider ${provider} --model ${modelName}:${params.thinking}`;
         } else {
@@ -206,39 +222,83 @@ export default function (pi: ExtensionAPI) {
         PI_AGENT_NAME: safeName,
       };
 
-      // For iTerm2, we need to handle the spawn context for proper layout
-      if (terminal instanceof Iterm2Adapter) {
-        const teammates = teamConfig.members.filter(m => m.agentType === "teammate" && m.tmuxPaneId.startsWith("iterm_"));
-        const lastTeammate = teammates.length > 0 ? teammates[teammates.length - 1] : null;
-        if (lastTeammate?.tmuxPaneId) {
-          terminal.setSpawnContext({ lastSessionId: lastTeammate.tmuxPaneId.replace("iterm_", "") });
-        } else {
-          terminal.setSpawnContext({});
-        }
-      }
+      let terminalId = "";
+      let isWindow = false;
 
-      let paneId = "";
       try {
-        paneId = terminal.spawn({
-          name: safeName,
-          cwd: params.cwd,
-          command: piCmd,
-          env: env,
-        });
+        if (useSeparateWindow) {
+          isWindow = true;
+          terminalId = terminal.spawnWindow({
+            name: safeName,
+            cwd: params.cwd,
+            command: piCmd,
+            env: env,
+            teamName: safeTeamName,
+          });
+          await teams.updateMember(safeTeamName, safeName, { windowId: terminalId });
+        } else {
+          if (terminal instanceof Iterm2Adapter) {
+            const teammates = teamConfig.members.filter(m => m.agentType === "teammate" && m.tmuxPaneId.startsWith("iterm_"));
+            const lastTeammate = teammates.length > 0 ? teammates[teammates.length - 1] : null;
+            if (lastTeammate?.tmuxPaneId) {
+              terminal.setSpawnContext({ lastSessionId: lastTeammate.tmuxPaneId.replace("iterm_", "") });
+            } else {
+              terminal.setSpawnContext({});
+            }
+          }
+
+          terminalId = terminal.spawn({
+            name: safeName,
+            cwd: params.cwd,
+            command: piCmd,
+            env: env,
+          });
+          await teams.updateMember(safeTeamName, safeName, { tmuxPaneId: terminalId });
+        }
       } catch (e) {
-        throw new Error(`Failed to spawn ${terminal.name} pane: ${e}`);
+        throw new Error(`Failed to spawn ${terminal.name} ${isWindow ? 'window' : 'pane'}: ${e}`);
       }
 
-      // Update member with paneId
-      await teams.updateMember(params.team_name, params.name, { tmuxPaneId: paneId });
-
       return {
-        content: [{ type: "text", text: `Teammate ${params.name} spawned in pane ${paneId}.` }],
-        details: { agentId: member.agentId, paneId },
+        content: [{ type: "text", text: `Teammate ${params.name} spawned in ${isWindow ? 'window' : 'pane'} ${terminalId}.` }],
+        details: { agentId: member.agentId, terminalId, isWindow },
       };
     },
   });
 
+  pi.registerTool({
+    name: "spawn_lead_window",
+    label: "Spawn Lead Window",
+    description: "Open the team lead in a separate OS window.",
+    parameters: Type.Object({
+      team_name: Type.String(),
+      cwd: Type.Optional(Type.String()),
+    }),
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
+      const safeTeamName = paths.sanitizeName(params.team_name);
+      if (!teams.teamExists(safeTeamName)) throw new Error(`Team ${params.team_name} does not exist`);
+      if (!terminal || !terminal.supportsWindows()) throw new Error("Windows mode not supported.");
+
+      const teamConfig = await teams.readConfig(safeTeamName);
+      const cwd = params.cwd || process.cwd();
+      const piBinary = process.argv[1] ? `node ${process.argv[1]}` : "pi";
+      let piCmd = piBinary;
+      if (teamConfig.defaultModel) {
+        const [provider, ...modelParts] = teamConfig.defaultModel.split('/');
+        piCmd = `${piBinary} --provider ${provider} --model ${modelParts.join('/')}`;
+      }
+
+      const env = { ...process.env, PI_TEAM_NAME: safeTeamName, PI_AGENT_NAME: "team-lead" };
+      try {
+        const windowId = terminal.spawnWindow({ name: "team-lead", cwd, command: piCmd, env, teamName: safeTeamName });
+        await teams.updateMember(safeTeamName, "team-lead", { windowId });
+        return { content: [{ type: "text", text: `Lead window spawned: ${windowId}` }], details: { windowId } };
+      } catch (e) {
+        throw new Error(`Failed: ${e}`);
+      }
+    }
+  });
+
   pi.registerTool({
     name: "send_message",
     label: "Send Message",
@@ -286,7 +346,7 @@ export default function (pi: ExtensionAPI) {
       agent_name: Type.Optional(Type.String({ description: "Whose inbox to read. Defaults to your own." })),
       unread_only: Type.Optional(Type.Boolean({ default: true })),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    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);
       return {
@@ -305,7 +365,7 @@ export default function (pi: ExtensionAPI) {
       subject: Type.String(),
       description: Type.String(),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const task = await tasks.createTask(params.team_name, params.subject, params.description);
       return {
         content: [{ type: "text", text: `Task ${task.id} created.` }],
@@ -354,11 +414,11 @@ export default function (pi: ExtensionAPI) {
   pi.registerTool({
     name: "task_list",
     label: "List Tasks",
-    description: "List all team tasks.",
+    description: "List all tasks for a team.",
     parameters: Type.Object({
       team_name: Type.String(),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const taskList = await tasks.listTasks(params.team_name);
       return {
         content: [{ type: "text", text: JSON.stringify(taskList, null, 2) }],
@@ -390,61 +450,39 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.registerTool({
-    name: "team_delete",
-    label: "Delete Team",
-    description: "Delete a team and all its data.",
+    name: "team_shutdown",
+    label: "Shutdown Team",
+    description: "Shutdown the entire team and close all panes/windows.",
     parameters: Type.Object({
       team_name: Type.String(),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const teamName = params.team_name;
       try {
         const config = await teams.readConfig(teamName);
         for (const member of config.members) {
-          if (member.name !== "team-lead") {
-            ctx.ui.notify(`Stopping teammate: ${member.name}`, "info");
-            await killTeammate(teamName, member);
-          }
+          await killTeammate(teamName, member);
         }
+        const dir = paths.teamDir(teamName);
+        const tasksDir = paths.taskDir(teamName);
+        if (fs.existsSync(tasksDir)) fs.rmSync(tasksDir, { recursive: true });
+        if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true });
+        return { content: [{ type: "text", text: `Team ${teamName} shut down.` }], details: {} };
       } catch (e) {
-        // config might not exist, ignore
+        throw new Error(`Failed to shutdown team: ${e}`);
       }
-
-      const dir = paths.teamDir(teamName);
-      const tasksDir = paths.taskDir(teamName);
-      if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true });
-      if (fs.existsSync(tasksDir)) fs.rmSync(tasksDir, { recursive: true });
-      return {
-        content: [{ type: "text", text: `Team ${teamName} deleted.` }],
-      };
-    },
-  });
-
-  pi.registerTool({
-    name: "read_config",
-    label: "Read Config",
-    description: "Read the current team configuration.",
-    parameters: Type.Object({
-      team_name: Type.String(),
-    }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const config = await teams.readConfig(params.team_name);
-      return {
-        content: [{ type: "text", text: JSON.stringify(config, null, 2) }],
-        details: { config },
-      };
     },
   });
 
   pi.registerTool({
-    name: "task_get",
-    label: "Get Task",
-    description: "Get full details of a specific task by ID.",
+    name: "task_read",
+    label: "Read Task",
+    description: "Read details of a specific task.",
     parameters: Type.Object({
       team_name: Type.String(),
       task_id: Type.String(),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const task = await tasks.readTask(params.team_name, params.task_id);
       return {
         content: [{ type: "text", text: JSON.stringify(task, null, 2) }],
@@ -453,29 +491,6 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
-  pi.registerTool({
-    name: "force_kill_teammate",
-    label: "Force Kill Teammate",
-    description: "Forcibly kill a teammate's terminal pane.",
-    parameters: Type.Object({
-      team_name: Type.String(),
-      agent_name: Type.String(),
-    }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const config = await teams.readConfig(params.team_name);
-      const member = config.members.find(m => m.name === params.agent_name);
-      if (!member) throw new Error(`Teammate ${params.agent_name} not found`);
-      
-      await killTeammate(params.team_name, member);
-
-      await teams.removeMember(params.team_name, params.agent_name);
-      await tasks.resetOwnerTasks(params.team_name, params.agent_name);
-      return {
-        content: [{ type: "text", text: `${params.agent_name} has been stopped.` }],
-      };
-    },
-  });
-
   pi.registerTool({
     name: "check_teammate",
     label: "Check Teammate",
@@ -484,18 +499,19 @@ export default function (pi: ExtensionAPI) {
       team_name: Type.String(),
       agent_name: Type.String(),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const config = await teams.readConfig(params.team_name);
       const member = config.members.find(m => m.name === params.agent_name);
       if (!member) throw new Error(`Teammate ${params.agent_name} not found`);
 
       let alive = false;
-      if (member.tmuxPaneId && terminal) {
+      if (member.windowId && terminal) {
+        alive = terminal.isWindowAlive(member.windowId);
+      } else if (member.tmuxPaneId && terminal) {
         alive = terminal.isAlive(member.tmuxPaneId);
       }
 
       const unreadCount = (await messaging.readInbox(params.team_name, params.agent_name, true, false)).length;
-
       return {
         content: [{ type: "text", text: JSON.stringify({ alive, unreadCount }, null, 2) }],
         details: { alive, unreadCount },
@@ -511,18 +527,14 @@ export default function (pi: ExtensionAPI) {
       team_name: Type.String(),
       agent_name: Type.String(),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const config = await teams.readConfig(params.team_name);
       const member = config.members.find(m => m.name === params.agent_name);
-      if (!member) throw new Error(`Teammate ${params.agent_name} not found`);
-
-      await killTeammate(params.team_name, member);
-
-      await teams.removeMember(params.team_name, params.agent_name);
-      await tasks.resetOwnerTasks(params.team_name, params.agent_name);
-      return {
-        content: [{ type: "text", text: `${params.agent_name} removed from team.` }],
-      };
+      if (member) {
+        await killTeammate(params.team_name, member);
+        await teams.removeMember(params.team_name, params.agent_name);
+      }
+      return { content: [{ type: "text", text: `Teammate ${params.agent_name} shutdown processed.` }], details: {} };
     },
   });
 }

package/package.json

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

package/src/adapters/iterm2-adapter.ts

@@ -1,11 +1,12 @@
 /**
  * iTerm2 Terminal Adapter
- * 
+ *
  * Implements the TerminalAdapter interface for iTerm2 terminal emulator.
  * Uses AppleScript for all operations.
  */
 
 import { TerminalAdapter, SpawnOptions, execCommand } from "../utils/terminal-adapter";
+import { spawnSync } from "node:child_process";
 
 /**
  * Context needed for iTerm2 spawning (tracks last pane for layout)
@@ -20,23 +21,36 @@ export class Iterm2Adapter implements TerminalAdapter {
   private spawnContext: Iterm2SpawnContext = {};
 
   detect(): boolean {
-    // iTerm2 is available if TERM_PROGRAM is iTerm.app and not in tmux/zellij
     return process.env.TERM_PROGRAM === "iTerm.app" && !process.env.TMUX && !process.env.ZELLIJ;
   }
 
+  /**
+   * Helper to execute AppleScript via stdin to avoid escaping issues with -e
+   */
+  private runAppleScript(script: string): { stdout: string; stderr: string; status: number | null } {
+    const result = spawnSync("osascript", ["-"], {
+      input: script,
+      encoding: "utf-8",
+    });
+    return {
+      stdout: result.stdout?.toString() ?? "",
+      stderr: result.stderr?.toString() ?? "",
+      status: result.status,
+    };
+  }
+
   spawn(options: SpawnOptions): string {
     const envStr = Object.entries(options.env)
       .filter(([k]) => k.startsWith("PI_"))
       .map(([k, v]) => `${k}=${v}`)
       .join(" ");
-    
+
     const itermCmd = `cd '${options.cwd}' && ${envStr} ${options.command}`;
     const escapedCmd = itermCmd.replace(/"/g, '\\"');
 
     let script: string;
-    
+
     if (!this.spawnContext.lastSessionId) {
-      // First teammate: split current session vertically (side-by-side)
       script = `tell application "iTerm2"
   tell current session of current window
     set newSession to split vertically with default profile
@@ -47,7 +61,6 @@ export class Iterm2Adapter implements TerminalAdapter {
   end tell
 end tell`;
     } else {
-      // Subsequent teammate: split the last teammate's session horizontally (stacking)
       script = `tell application "iTerm2"
   repeat with aWindow in windows
     repeat with aTab in tabs of aWindow
@@ -67,21 +80,21 @@ end tell`;
 end tell`;
     }
 
-    const result = execCommand("osascript", ["-e", script]);
-    
+    const result = this.runAppleScript(script);
+
     if (result.status !== 0) {
       throw new Error(`osascript failed with status ${result.status}: ${result.stderr}`);
     }
 
     const sessionId = result.stdout.toString().trim();
     this.spawnContext.lastSessionId = sessionId;
-    
+
     return `iterm_${sessionId}`;
   }
 
   kill(paneId: string): void {
-    if (!paneId || !paneId.startsWith("iterm_")) {
-      return; // Not an iTerm2 pane
+    if (!paneId || !paneId.startsWith("iterm_") || paneId.startsWith("iterm_win_")) {
+      return;
     }
 
     const itermId = paneId.replace("iterm_", "");
@@ -99,15 +112,15 @@ end tell`;
 end tell`;
 
     try {
-      execCommand("osascript", ["-e", script]);
+      this.runAppleScript(script);
     } catch {
-      // Ignore errors - session may already be closed
+      // Ignore errors
     }
   }
 
   isAlive(paneId: string): boolean {
-    if (!paneId || !paneId.startsWith("iterm_")) {
-      return false; // Not an iTerm2 pane
+    if (!paneId || !paneId.startsWith("iterm_") || paneId.startsWith("iterm_win_")) {
+      return false;
     }
 
     const itermId = paneId.replace("iterm_", "");
@@ -124,7 +137,7 @@ end tell`;
 end tell`;
 
     try {
-      const result = execCommand("osascript", ["-e", script]);
+      const result = this.runAppleScript(script);
       return result.stdout.includes("Alive");
     } catch {
       return false;
@@ -132,16 +145,145 @@ end tell`;
   }
 
   setTitle(title: string): void {
+    const escapedTitle = title.replace(/"/g, '\\"');
+    const script = `tell application "iTerm2" to tell current session of current window
+      set name to "${escapedTitle}"
+    end tell`;
     try {
-      execCommand("osascript", [
-        "-e",
-        `tell application "iTerm2" to tell current session of current window to set name to "${title}"`
-      ]);
+      this.runAppleScript(script);
     } catch {
       // Ignore errors
     }
   }
 
+  /**
+   * iTerm2 supports spawning separate OS windows via AppleScript
+   */
+  supportsWindows(): boolean {
+    return true;
+  }
+
+  /**
+   * Spawn a new separate OS window with the given options.
+   */
+  spawnWindow(options: SpawnOptions): string {
+    const envStr = Object.entries(options.env)
+      .filter(([k]) => k.startsWith("PI_"))
+      .map(([k, v]) => `${k}=${v}`)
+      .join(" ");
+
+    const itermCmd = `cd '${options.cwd}' && ${envStr} ${options.command}`;
+    const escapedCmd = itermCmd.replace(/"/g, '\\"');
+
+    const windowTitle = options.teamName
+      ? `${options.teamName}: ${options.name}`
+      : options.name;
+
+    const escapedTitle = windowTitle.replace(/"/g, '\\"');
+
+    const script = `tell application "iTerm2"
+  set newWindow to (create window with default profile)
+  tell current session of newWindow
+    -- Set the session name (tab title)
+    set name to "${escapedTitle}"
+    -- Set window title via escape sequence (OSC 2)
+    -- We use double backslashes for AppleScript to emit a single backslash to the shell
+    write text "printf '\\\\033]2;${escapedTitle}\\\\007'"
+    -- Execute the command
+    write text "cd '${options.cwd}' && ${escapedCmd}"
+    return id of newWindow
+  end tell
+end tell`;
+
+    const result = this.runAppleScript(script);
+
+    if (result.status !== 0) {
+      throw new Error(`osascript failed with status ${result.status}: ${result.stderr}`);
+    }
+
+    const windowId = result.stdout.toString().trim();
+    return `iterm_win_${windowId}`;
+  }
+
+  /**
+   * Set the title of a specific window.
+   */
+  setWindowTitle(windowId: string, title: string): void {
+    if (!windowId || !windowId.startsWith("iterm_win_")) {
+      return;
+    }
+
+    const itermId = windowId.replace("iterm_win_", "");
+    const escapedTitle = title.replace(/"/g, '\\"');
+
+    const script = `tell application "iTerm2"
+  repeat with aWindow in windows
+    if id of aWindow is "${itermId}" then
+      tell current session of aWindow
+        write text "printf '\\\\033]2;${escapedTitle}\\\\007'"
+      end tell
+      exit repeat
+    end if
+  end repeat
+end tell`;
+
+    try {
+      this.runAppleScript(script);
+    } catch {
+      // Silently fail
+    }
+  }
+
+  /**
+   * Kill/terminate a window.
+   */
+  killWindow(windowId: string): void {
+    if (!windowId || !windowId.startsWith("iterm_win_")) {
+      return;
+    }
+
+    const itermId = windowId.replace("iterm_win_", "");
+    const script = `tell application "iTerm2"
+  repeat with aWindow in windows
+    if id of aWindow is "${itermId}" then
+      close aWindow
+      return "Closed"
+    end if
+  end repeat
+end tell`;
+
+    try {
+      this.runAppleScript(script);
+    } catch {
+      // Silently fail
+    }
+  }
+
+  /**
+   * Check if a window is still alive/active.
+   */
+  isWindowAlive(windowId: string): boolean {
+    if (!windowId || !windowId.startsWith("iterm_win_")) {
+      return false;
+    }
+
+    const itermId = windowId.replace("iterm_win_", "");
+    const script = `tell application "iTerm2"
+  repeat with aWindow in windows
+    if id of aWindow is "${itermId}" then
+      return "Alive"
+    end if
+  end repeat
+end tell`;
+
+    try {
+      const result = this.runAppleScript(script);
+      return result.stdout.includes("Alive");
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Set the spawn context (used to restore state when needed)
    */

package/src/adapters/terminal-registry.ts

@@ -99,3 +99,22 @@ export function setAdapter(adapter: TerminalAdapter): void {
 export function hasTerminalAdapter(): boolean {
   return getTerminalAdapter() !== null;
 }
+
+/**
+ * Check if the current terminal supports spawning separate OS windows.
+ * 
+ * @returns true if the detected terminal supports windows (iTerm2, WezTerm)
+ */
+export function supportsWindows(): boolean {
+  const adapter = getTerminalAdapter();
+  return adapter?.supportsWindows() ?? false;
+}
+
+/**
+ * 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/tmux-adapter.ts

@@ -74,4 +74,39 @@ export class TmuxAdapter implements TerminalAdapter {
       // Ignore errors
     }
   }
+
+  /**
+   * tmux does not support spawning separate OS windows
+   */
+  supportsWindows(): boolean {
+    return false;
+  }
+
+  /**
+   * Not supported - throws error
+   */
+  spawnWindow(_options: SpawnOptions): string {
+    throw new Error("tmux does not support spawning separate OS windows. Use iTerm2 or WezTerm instead.");
+  }
+
+  /**
+   * Not supported - no-op
+   */
+  setWindowTitle(_windowId: string, _title: string): void {
+    // Not supported
+  }
+
+  /**
+   * Not supported - no-op
+   */
+  killWindow(_windowId: string): void {
+    // Not supported
+  }
+
+  /**
+   * Not supported - always returns false
+   */
+  isWindowAlive(_windowId: string): boolean {
+    return false;
+  }
 }

package/src/adapters/wezterm-adapter.ts

@@ -163,4 +163,142 @@ export class WezTermAdapter implements TerminalAdapter {
       execCommand(weztermBin, ["cli", "set-tab-title", title]);
     } catch {}
   }
+
+  /**
+   * WezTerm supports spawning separate OS windows via CLI
+   */
+  supportsWindows(): boolean {
+    return this.findWeztermBinary() !== null;
+  }
+
+  /**
+   * Spawn a new separate OS window with the given options.
+   * Uses `wezterm cli spawn --new-window` and sets the window title.
+   */
+  spawnWindow(options: SpawnOptions): string {
+    const weztermBin = this.findWeztermBinary();
+    if (!weztermBin) {
+      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
+    ];
+
+    const result = execCommand(weztermBin, spawnArgs);
+    if (result.status !== 0) {
+      throw new Error(`wezterm spawn-window failed: ${result.stderr}`);
+    }
+
+    // The output is the pane ID, we need to find the window ID
+    const paneId = result.stdout.trim();
+    
+    // Query to get window ID from pane ID
+    const windowId = this.getWindowIdFromPaneId(parseInt(paneId, 10));
+    
+    // Set the window title if we found the window
+    if (windowId !== null) {
+      this.setWindowTitle(`wezterm_win_${windowId}`, windowTitle);
+    }
+
+    return `wezterm_win_${windowId || paneId}`;
+  }
+
+  /**
+   * Get window ID from a pane ID by querying WezTerm
+   */
+  private getWindowIdFromPaneId(paneId: number): number | null {
+    const weztermBin = this.findWeztermBinary();
+    if (!weztermBin) return null;
+
+    const result = execCommand(weztermBin, ["cli", "list", "--format", "json"]);
+    if (result.status !== 0) return null;
+
+    try {
+      const allPanes = JSON.parse(result.stdout);
+      const pane = allPanes.find((p: any) => p.pane_id === paneId);
+      return pane?.window_id ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Set the title of a specific window.
+   */
+  setWindowTitle(windowId: string, title: string): void {
+    if (!windowId?.startsWith("wezterm_win_")) return;
+    
+    const weztermBin = this.findWeztermBinary();
+    if (!weztermBin) return;
+
+    const weztermWindowId = windowId.replace("wezterm_win_", "");
+    
+    try {
+      execCommand(weztermBin, ["cli", "set-window-title", "--window-id", weztermWindowId, title]);
+    } catch {
+      // Silently fail
+    }
+  }
+
+  /**
+   * Kill/terminate a window.
+   */
+  killWindow(windowId: string): void {
+    if (!windowId?.startsWith("wezterm_win_")) return;
+    
+    const weztermBin = this.findWeztermBinary();
+    if (!weztermBin) return;
+
+    const weztermWindowId = windowId.replace("wezterm_win_", "");
+    
+    try {
+      // WezTerm doesn't have a direct kill-window command, so we kill all panes in the window
+      const result = execCommand(weztermBin, ["cli", "list", "--format", "json"]);
+      if (result.status !== 0) return;
+
+      const allPanes = JSON.parse(result.stdout);
+      const windowPanes = allPanes.filter((p: any) => p.window_id.toString() === weztermWindowId);
+      
+      for (const pane of windowPanes) {
+        execCommand(weztermBin, ["cli", "kill-pane", "--pane-id", pane.pane_id.toString()]);
+      }
+    } catch {
+      // Silently fail
+    }
+  }
+
+  /**
+   * Check if a window is still alive/active.
+   */
+  isWindowAlive(windowId: string): boolean {
+    if (!windowId?.startsWith("wezterm_win_")) return false;
+    
+    const weztermBin = this.findWeztermBinary();
+    if (!weztermBin) return false;
+
+    const weztermWindowId = windowId.replace("wezterm_win_", "");
+    
+    try {
+      const result = execCommand(weztermBin, ["cli", "list", "--format", "json"]);
+      if (result.status !== 0) return false;
+
+      const allPanes = JSON.parse(result.stdout);
+      return allPanes.some((p: any) => p.window_id.toString() === weztermWindowId);
+    } catch {
+      return false;
+    }
+  }
 }

package/src/adapters/zellij-adapter.ts

@@ -59,4 +59,39 @@ export class ZellijAdapter implements TerminalAdapter {
     // Zellij pane titles are set via --name at spawn time
     // No runtime title changing supported
   }
+
+  /**
+   * Zellij does not support spawning separate OS windows
+   */
+  supportsWindows(): boolean {
+    return false;
+  }
+
+  /**
+   * Not supported - throws error
+   */
+  spawnWindow(_options: SpawnOptions): string {
+    throw new Error("Zellij does not support spawning separate OS windows. Use iTerm2 or WezTerm instead.");
+  }
+
+  /**
+   * Not supported - no-op
+   */
+  setWindowTitle(_windowId: string, _title: string): void {
+    // Not supported
+  }
+
+  /**
+   * Not supported - no-op
+   */
+  killWindow(_windowId: string): void {
+    // Not supported
+  }
+
+  /**
+   * Not supported - always returns false
+   */
+  isWindowAlive(_windowId: string): boolean {
+    return false;
+  }
 }

package/src/utils/models.ts

@@ -5,6 +5,7 @@ export interface Member {
   model?: string;
   joinedAt: number;
   tmuxPaneId: string;
+  windowId?: string;
   cwd: string;
   subscriptions: any[];
   prompt?: string;
@@ -23,6 +24,7 @@ export interface TeamConfig {
   leadSessionId: string;
   members: Member[];
   defaultModel?: string;
+  separateWindows?: boolean;
 }
 
 export interface TaskFile {

package/src/utils/teams.ts

@@ -13,7 +13,8 @@ export function createTeam(
   sessionId: string,
   leadAgentId: string,
   description = "",
-  defaultModel?: string
+  defaultModel?: string,
+  separateWindows?: boolean
 ): TeamConfig {
   const dir = teamDir(name);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -39,6 +40,7 @@ export function createTeam(
     leadSessionId: sessionId,
     members: [leadMember],
     defaultModel,
+    separateWindows,
   };
 
   fs.writeFileSync(configPath(name), JSON.stringify(config, null, 2));

package/src/utils/terminal-adapter.ts

@@ -8,17 +8,19 @@
 import { spawnSync } from "node:child_process";
 
 /**
- * Options for spawning a new terminal pane
+ * Options for spawning a new terminal pane or window
  */
 export interface SpawnOptions {
-  /** Name/identifier for the pane */
+  /** Name/identifier for the pane/window */
   name: string;
-  /** Working directory for the new pane */
+  /** Working directory for the new pane/window */
   cwd: string;
-  /** Command to execute in the pane */
+  /** Command to execute in the pane/window */
   command: string;
   /** Environment variables to set (key-value pairs) */
   env: Record<string, string>;
+  /** Team name for window title formatting (e.g., "team: agent") */
+  teamName?: string;
 }
 
 /**
@@ -70,6 +72,49 @@ export interface TerminalAdapter {
    * @param title - The title to set
    */
   setTitle(title: string): void;
+
+  /**
+   * Check if this terminal supports spawning separate OS windows.
+   * Terminals like tmux and Zellij only support panes/tabs within a session.
+   * 
+   * @returns true if spawnWindow() is supported
+   */
+  supportsWindows(): boolean;
+
+  /**
+   * Spawn a new separate OS window with the given options.
+   * Only available if supportsWindows() returns true.
+   * 
+   * @param options - Spawn configuration
+   * @returns Window ID that can be used for subsequent operations
+   * @throws Error if spawn fails or not supported
+   */
+  spawnWindow(options: SpawnOptions): string;
+
+  /**
+   * Set the title of a specific window.
+   * Used for identifying windows in the OS window manager.
+   * 
+   * @param windowId - The window ID returned from spawnWindow()
+   * @param title - The title to set
+   */
+  setWindowTitle(windowId: string, title: string): void;
+
+  /**
+   * Kill/terminate a window.
+   * Should be idempotent - no error if window doesn't exist.
+   * 
+   * @param windowId - The window ID returned from spawnWindow()
+   */
+  killWindow(windowId: string): void;
+
+  /**
+   * Check if a window is still alive/active.
+   * 
+   * @param windowId - The window ID returned from spawnWindow()
+   * @returns true if window exists and is active
+   */
+  isWindowAlive(windowId: string): boolean;
 }
 
 /**