pi-teams 0.5.2 → 0.7.3

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**.
+**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, iTerm2, or Zellij.
 
 ### 🖥️ pi-teams in Action
 
@@ -16,95 +16,76 @@ Open your Pi terminal and type:
 pi install npm:pi-teams
 ```
 
----
+## 🚀 Quick Start
+
+```bash
+# 1. Start a team (inside tmux, Zellij, or iTerm2)
+"Create a team named 'my-team' using 'gpt-4o'"
+
+# 2. Spawn teammates
+"Spawn 'security-bot' to scan for vulnerabilities"
+"Spawn 'frontend-dev' using 'haiku' for quick iterations"
+
+# 3. Create and assign tasks
+"Create a task for security-bot: 'Audit auth endpoints'"
+
+# 4. Review and approve work
+"List all tasks and approve any pending plans"
+```
 
 ## 🌟 What can it do?
 
+### Core Features
 - **Spawn Specialists**: Create agents like "Security Expert" or "Frontend Pro" to handle sub-tasks in parallel.
 - **Shared Task Board**: Keep everyone on the same page with a persistent list of tasks and their status.
 - **Agent Messaging**: Agents can send direct messages to each other and to you (the Team Lead) to report progress.
 - **Autonomous Work**: Teammates automatically "wake up," read their instructions, and poll their inboxes for new work while idle.
 - **Beautiful UI**: Optimized vertical splits in `tmux` with clear labels so you always know who is doing what.
 
----
+### Advanced Features
+- **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).
+- **Thinking Level Control**: Set per-teammate thinking levels (`off`, `minimal`, `low`, `medium`, `high`) to balance speed vs. reasoning depth.
 
-## 💬 How to use it (Examples)
-
-You don't need to learn complex code commands. Just talk to Pi in plain English!
+## 💬 Key Examples
 
 ### 1. Start a Team
 > **You:** "Create a team named 'my-app-audit' for reviewing the codebase."
 
-**Pro Tip:** You can also set a default model for the whole team!
+**Set a default model for the whole team:**
 > **You:** "Create a team named 'Research' and use 'gpt-4o' for everyone."
 
-### 2. Spawn a Teammate
+### 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."
 
-**Pro Tip:** You can specify a different model for a specific teammate!
+**Use a different model:**
 > **You:** "Spawn a teammate named 'speed-bot' using 'haiku' to quickly run some benchmarks."
 
-### 3. Assign a Task
-> **You:** "Create a task for security-bot: 'Check the .env.example file for sensitive defaults' and set it to in_progress."
-
-### 4. Send a Message
-> **You:** "Tell security-bot to focus on the 'config/' directory first."
-> *The lead agent uses `send_message` to put an instruction in the teammate's inbox.*
-
-### 5. Inter-Agent Communication
-> Teammates can also talk to each other! For example, a `frontend-bot` can message a `backend-bot` to coordinate on an API schema without your intervention.
+**Require plan approval:**
+> **You:** "Spawn a teammate named 'refactor-bot' and require plan approval before they make any changes."
 
-### 6. Check on Progress
-> **You:** "How is the team doing? List all tasks and check my inbox for any messages."
+**Customize model and thinking level:**
+> **You:** "Spawn a teammate named 'architect-bot' using 'gpt-4o' with 'high' thinking level for deep reasoning."
 
-### 7. Shut Down the Team
-> **You:** "We're done. Shut down the team and close the panes."
-
----
-
-## 🛠 Available Tools
-
-Pi automatically uses these tools when you give instructions like the examples above.
-
-### Team Management
-- `team_create`: Start a new team. (Optional: `default_model`)
-- `team_delete`: Delete a team and its data.
-- `read_config`: Get details about the team and its members.
-
-### Teammates
-- `spawn_teammate`: Launch a new agent into a `tmux` pane with a role and instructions. (Optional: `model`)
-- `check_teammate`: See if a teammate is still running or has unread messages.
-- `force_kill_teammate`: Stop a teammate and remove them from the team.
-- `process_shutdown_approved`: Orderly shutdown for a finished teammate.
-
-### Task Management
-- `task_create`: Create a new task.
-- `task_list`: List all tasks and their current status.
-- `task_get`: Get full details of a specific task.
-- `task_update`: Update a task's status or owner.
-
-### Messaging
-- `send_message`: Send a message to a teammate or lead.
-- `read_inbox`: Read incoming messages for an agent.
+### 3. Assign Task & Get Approval
+> **You:** "Create a task for security-bot: 'Check the .env.example file for sensitive defaults' and set it to in_progress."
 
----
+Teammates in `planning` mode will use `task_submit_plan`. As the lead, review their work:
+> **You:** "Review refactor-bot's plan for task 5. If it looks good, approve it. If not, reject it with feedback on the test coverage."
 
-## 🤖 Automated Behavior
+### 4. Broadcast to Team
+> **You:** "Broadcast to the entire team: 'The API endpoint has changed to /v2. Please update your work accordingly.'"
 
-- **Initial Greeting**: When a teammate is spawned, they will automatically send a message saying they've started and are checking their inbox.
-- **Idle Polling**: Teammates check for new messages every 30 seconds if they are idle.
-- **Context Injection**: Each teammate is given a custom system prompt that defines their role and instructions for the team environment.
+### 5. Shut Down Team
+> **You:** "We're done. Shut down the team and close the panes."
 
 ---
 
-## 📂 Configuration & Data
+## 📚 Learn More
 
-All team and task data is stored in your home directory:
-`~/.pi/teams/` and `~/.pi/tasks/`
-
-You can manually inspect these JSON files if you ever need to debug your team's configuration or message history.
-
----
+- **[Full Usage Guide](docs/guide.md)** - Detailed examples, hook system, best practices, and troubleshooting
+- **[Tool Reference](docs/reference.md)** - Complete documentation of all tools and parameters
 
 ## 🪟 Terminal Requirements: tmux, Zellij, or iTerm2
 
@@ -112,32 +93,29 @@ To show multiple agents on one screen, **pi-teams** requires a way to manage ter
 
 ### Option 1: tmux (Recommended)
 
-#### 1. Install tmux
+Install tmux:
 - **macOS**: `brew install tmux`
 - **Linux**: `sudo apt install tmux`
 
-#### 2. How to run it
-Before you start a team, you **must** be inside a tmux session. Simply type:
+How to run:
 ```bash
-tmux
+tmux  # Start tmux session
+pi   # Start pi inside tmux
 ```
-Then start `pi` inside that window.
 
 ### Option 2: Zellij
 
-If you prefer **Zellij**, simply start `pi` inside a Zellij session. **pi-teams** will detect it via the `ZELLIJ` environment variable and use `zellij run` to spawn teammates in new panes.
+Simply start `pi` inside a Zellij session. **pi-teams** will detect it via the `ZELLIJ` environment variable and use `zellij run` to spawn teammates in new panes.
 
 ### 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.
 
----
-
 ## 📜 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). 
+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).
 
-We have adapted the original MCP coordination protocol to work natively as a **Pi Package**, adding features like auto-starting teammates, balanced vertical UI layouts, and automatic inbox polling to make the experience seamless for Pi users.
+We have adapted the original MCP coordination protocol to work natively as a **Pi Package**, adding features like auto-starting teammates, balanced vertical UI layouts, automatic inbox polling, plan approval mode, broadcast messaging, and quality gate hooks.
 
 ## 📄 License
 MIT

package/extensions/index.ts

@@ -6,7 +6,8 @@ import * as teams from "../src/utils/teams";
 import * as tasks from "../src/utils/tasks";
 import * as messaging from "../src/utils/messaging";
 import { Member } from "../src/utils/models";
-import { execSync, spawnSync } from "node:child_process";
+import { getTerminalAdapter } from "../src/adapters/terminal-registry";
+import { Iterm2Adapter } from "../src/adapters/iterm2-adapter";
 import path from "node:path";
 import fs from "node:fs";
 
@@ -15,6 +16,9 @@ export default function (pi: ExtensionAPI) {
   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) => {
     paths.ensureDirs();
     if (isTeammate) {
@@ -26,15 +30,9 @@ export default function (pi: ExtensionAPI) {
       // Use a shorter, more prominent status at the beginning if possible
       ctx.ui.setStatus("00-pi-teams", `[${agentName.toUpperCase()}]`); 
       
-      // Also set the tmux pane title for better visibility
-      try {
-        if (process.env.TMUX) {
-          spawnSync("tmux", ["select-pane", "-T", agentName]);
-        } else if (process.env.TERM_PROGRAM === "iTerm.app") {
-          spawnSync("osascript", ["-e", `tell application "iTerm2" to tell current session of current window to set name to "${agentName}"`]);
-        }
-      } catch (e) {
-        // ignore
+      // Set the terminal pane title for better visibility
+      if (terminal) {
+        terminal.setTitle(agentName);
       }
       
       // Auto-trigger the first turn for teammates
@@ -60,8 +58,27 @@ export default function (pi: ExtensionAPI) {
   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 {
+          const teamConfig = await teams.readConfig(teamName);
+          const member = teamConfig.members.find(m => m.name === agentName);
+          if (member && member.model) {
+            modelInfo = `\nYou are currently using model: ${member.model}`;
+            if (member.thinking) {
+              modelInfo += ` with thinking level: ${member.thinking}`;
+            }
+            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
+        }
+      }
+
       return {
-        systemPrompt: event.systemPrompt + `\n\nYou are teammate '${agentName}' on team '${teamName}'.\nYour lead is 'team-lead'.\nStart by calling read_inbox(team_name="${teamName}") to get your initial instructions.`,
+        systemPrompt: event.systemPrompt + `\n\nYou are teammate '${agentName}' on team '${teamName}'.\nYour lead is 'team-lead'.${modelInfo}\nStart by calling read_inbox(team_name="${teamName}") to get your initial instructions.`,
       };
     }
   });
@@ -80,32 +97,8 @@ export default function (pi: ExtensionAPI) {
       }
     }
 
-    if (member.tmuxPaneId) {
-      try {
-        if (member.tmuxPaneId.startsWith("iterm_")) {
-          const itermId = member.tmuxPaneId.replace("iterm_", "");
-          const script = `tell application "iTerm2"
-  repeat with aWindow in windows
-    repeat with aTab in tabs of aWindow
-      repeat with aSession in sessions of aTab
-        if id of aSession is "${itermId}" then
-          close aSession
-          return "Closed"
-        end if
-      end repeat
-    end repeat
-  end repeat
-end tell`;
-          spawnSync("osascript", ["-e", script]);
-        } else if (member.tmuxPaneId.startsWith("zellij_")) {
-          // Zellij is expected to close on process exit (using --close-on-exit)
-        } else {
-          // Use -t with the pane_id
-          spawnSync("tmux", ["kill-pane", "-t", member.tmuxPaneId.trim()]);
-        }
-      } catch (e) {
-        // ignore
-      }
+    if (member.tmuxPaneId && terminal) {
+      terminal.kill(member.tmuxPaneId);
     }
   }
 
@@ -119,7 +112,7 @@ end tell`;
       description: Type.Optional(Type.String()),
       default_model: Type.Optional(Type.String()),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const config = teams.createTeam(params.team_name, "local-session", "lead-agent", params.description, params.default_model);
       return {
         content: [{ type: "text", text: `Team ${params.team_name} created.` }],
@@ -131,15 +124,17 @@ end tell`;
   pi.registerTool({
     name: "spawn_teammate",
     label: "Spawn Teammate",
-    description: "Spawn a new teammate in a tmux pane.",
+    description: "Spawn a new teammate in a terminal pane.",
     parameters: Type.Object({
       team_name: Type.String(),
       name: Type.String(),
       prompt: Type.String(),
       cwd: Type.String(),
       model: Type.Optional(Type.String()),
+      thinking: Type.Optional(StringEnum(["off", "minimal", "low", "medium", "high"])),
+      plan_mode_required: Type.Optional(Type.Boolean({ default: false })),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const safeName = paths.sanitizeName(params.name);
       const safeTeamName = paths.sanitizeName(params.team_name);
 
@@ -147,8 +142,28 @@ end tell`;
         throw new Error(`Team ${params.team_name} does not exist`);
       }
 
+      if (!terminal) {
+        throw new Error("No terminal adapter detected. Ensure you're running in tmux, iTerm2, or Zellij.");
+      }
+
       const teamConfig = await teams.readConfig(safeTeamName);
-      const chosenModel = params.model || teamConfig.defaultModel;
+      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-')) {
+            chosenModel = `anthropic/${chosenModel}`;
+          }
+        }
+      }
 
       const member: Member = {
         agentId: `${safeName}@${safeTeamName}`,
@@ -161,88 +176,58 @@ end tell`;
         subscriptions: [],
         prompt: params.prompt,
         color: "blue",
+        thinking: params.thinking,
+        planModeRequired: params.plan_mode_required,
       };
 
       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 piCmd = piBinary;
-      
-      let paneId = "";
-      try {
-        if (process.env.ZELLIJ && !process.env.TMUX) {
-          const zellijArgs = [
-            "run", 
-            "--name", safeName, 
-            "--cwd", params.cwd, 
-            "--close-on-exit",
-            "--", 
-            "env", `PI_TEAM_NAME=${safeTeamName}`, `PI_AGENT_NAME=${safeName}`,
-            "sh", "-c", piCmd
-          ];
-          spawnSync("zellij", zellijArgs);
-          paneId = `zellij_${safeName}`;
-        } else if (process.env.TERM_PROGRAM === "iTerm.app" && !process.env.TMUX && !process.env.ZELLIJ) {
-          const itermCmd = `cd '${params.cwd}' && PI_TEAM_NAME=${safeTeamName} PI_AGENT_NAME=${safeName} ${piCmd}`;
-          const teammates = teamConfig.members.filter(m => m.agentType === "teammate" && m.tmuxPaneId.startsWith("iterm_"));
-          const lastTeammate = teammates.length > 0 ? teammates[teammates.length - 1] : null;
-          
-          let script = "";
-          if (!lastTeammate) {
-            // 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
-    tell newSession
-      write text "${itermCmd.replace(/"/g, '\\"')}"
-      return id
-    end tell
-  end tell
-end tell`;
-          } else {
-            // Subsequent teammate: split the last teammate's session horizontally (stacking them)
-            const lastSessionId = lastTeammate.tmuxPaneId.replace("iterm_", "");
-            script = `tell application "iTerm2"
-  repeat with aWindow in windows
-    repeat with aTab in tabs of aWindow
-      repeat with aSession in sessions of aTab
-        if id of aSession is "${lastSessionId}" then
-          tell aSession
-            set newSession to split horizontally with default profile
-            tell newSession
-              write text "${itermCmd.replace(/"/g, '\\"')}"
-              return id
-            end tell
-          end tell
-        end if
-      end repeat
-    end repeat
-  end repeat
-end tell`;
-          }
-          const result = spawnSync("osascript", ["-e", script]);
-          if (result.status !== 0) throw new Error(`osascript failed with status ${result.status}: ${result.stderr.toString()}`);
-          paneId = `iterm_${result.stdout.toString().trim()}`;
+      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 {
-          const tmuxArgs = [
-            "split-window", 
-            "-h", "-dP", 
-            "-F", "#{pane_id}", 
-            "-c", params.cwd, 
-            "env", `PI_TEAM_NAME=${safeTeamName}`, `PI_AGENT_NAME=${safeName}`,
-            "sh", "-c", piCmd
-          ];
-          const result = spawnSync("tmux", tmuxArgs);
-          if (result.status !== 0) throw new Error(`tmux failed with status ${result.status}: ${result.stderr.toString()}`);
-          paneId = result.stdout.toString().trim();
-          spawnSync("tmux", ["set-window-option", "main-pane-width", "60%"]);
-          spawnSync("tmux", ["select-layout", "main-vertical"]);
+          piCmd = `${piBinary} --provider ${provider} --model ${modelName}`;
         }
-      } catch (e) {
-        throw new Error(`Failed to spawn ${process.env.ZELLIJ && !process.env.TMUX ? "zellij" : (process.env.TERM_PROGRAM === "iTerm.app" ? "iTerm2" : "tmux")} pane: ${e}`);
+      } else if (params.thinking) {
+        piCmd = `${piBinary} --thinking ${params.thinking}`;
       }
 
+      const env: Record<string, string> = {
+        ...process.env,
+        PI_TEAM_NAME: safeTeamName,
+        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 paneId = "";
+      try {
+        paneId = terminal.spawn({
+          name: safeName,
+          cwd: params.cwd,
+          command: piCmd,
+          env: env,
+        });
+      } catch (e) {
+        throw new Error(`Failed to spawn ${terminal.name} pane: ${e}`);
+      }
 
       // Update member with paneId
       await teams.updateMember(params.team_name, params.name, { tmuxPaneId: paneId });
@@ -264,10 +249,30 @@ end tell`;
       content: Type.String(),
       summary: Type.String(),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       await messaging.sendPlainMessage(params.team_name, agentName, params.recipient, params.content, params.summary);
       return {
         content: [{ type: "text", text: `Message sent to ${params.recipient}.` }],
+        details: {},
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "broadcast_message",
+    label: "Broadcast Message",
+    description: "Broadcast a message to all team members except the sender.",
+    parameters: Type.Object({
+      team_name: Type.String(),
+      content: Type.String(),
+      summary: Type.String(),
+      color: Type.Optional(Type.String()),
+    }),
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
+      await messaging.broadcastMessage(params.team_name, agentName, params.content, params.summary, params.color);
+      return {
+        content: [{ type: "text", text: `Message broadcasted to all team members.` }],
+        details: {},
       };
     },
   });
@@ -309,6 +314,43 @@ end tell`;
     },
   });
 
+  pi.registerTool({
+    name: "task_submit_plan",
+    label: "Submit Plan",
+    description: "Submit a plan for a task, updating its status to 'planning'.",
+    parameters: Type.Object({
+      team_name: Type.String(),
+      task_id: Type.String(),
+      plan: Type.String(),
+    }),
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
+      const updated = await tasks.submitPlan(params.team_name, params.task_id, params.plan);
+      return {
+        content: [{ type: "text", text: `Plan submitted for task ${params.task_id}.` }],
+        details: { task: updated },
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "task_evaluate_plan",
+    label: "Evaluate Plan",
+    description: "Evaluate a submitted plan for a task.",
+    parameters: Type.Object({
+      team_name: Type.String(),
+      task_id: Type.String(),
+      action: StringEnum(["approve", "reject"]),
+      feedback: Type.Optional(Type.String({ description: "Required for rejection" })),
+    }),
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
+      const updated = await tasks.evaluatePlan(params.team_name, params.task_id, params.action as any, params.feedback);
+      return {
+        content: [{ type: "text", text: `Plan for task ${params.task_id} has been ${params.action}d.` }],
+        details: { task: updated },
+      };
+    },
+  });
+
   pi.registerTool({
     name: "task_list",
     label: "List Tasks",
@@ -332,10 +374,10 @@ end tell`;
     parameters: Type.Object({
       team_name: Type.String(),
       task_id: Type.String(),
-      status: Type.Optional(StringEnum(["pending", "in_progress", "completed", "deleted"])),
+      status: Type.Optional(StringEnum(["pending", "planning", "in_progress", "completed", "deleted"])),
       owner: Type.Optional(Type.String()),
     }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const updated = await tasks.updateTask(params.team_name, params.task_id, {
         status: params.status as any,
         owner: params.owner,
@@ -414,7 +456,7 @@ end tell`;
   pi.registerTool({
     name: "force_kill_teammate",
     label: "Force Kill Teammate",
-    description: "Forcibly kill a teammate's tmux target.",
+    description: "Forcibly kill a teammate's terminal pane.",
     parameters: Type.Object({
       team_name: Type.String(),
       agent_name: Type.String(),
@@ -448,33 +490,8 @@ end tell`;
       if (!member) throw new Error(`Teammate ${params.agent_name} not found`);
 
       let alive = false;
-      if (member.tmuxPaneId) {
-        try {
-          if (member.tmuxPaneId.startsWith("zellij_")) {
-            // Assume alive if it's zellij for now
-            alive = true;
-          } else if (member.tmuxPaneId.startsWith("iterm_")) {
-            const itermId = member.tmuxPaneId.replace("iterm_", "");
-            const script = `tell application "iTerm2"
-  repeat with aWindow in windows
-    repeat with aTab in tabs of aWindow
-      repeat with aSession in sessions of aTab
-        if id of aSession is "${itermId}" then
-          return "Alive"
-        end if
-      end repeat
-    end repeat
-  end repeat
-end tell`;
-            const result = spawnSync("osascript", ["-e", script]);
-            alive = result.stdout.toString().includes("Alive");
-          } else {
-            execSync(`tmux has-session -t ${member.tmuxPaneId}`);
-            alive = true;
-          }
-        } catch (e) {
-          alive = false;
-        }
+      if (member.tmuxPaneId && terminal) {
+        alive = terminal.isAlive(member.tmuxPaneId);
       }
 
       const unreadCount = (await messaging.readInbox(params.team_name, params.agent_name, true, false)).length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-teams",
-  "version": "0.5.2",
+  "version": "0.7.3",
   "description": "Agent teams for pi, ported from claude-code-teams-mcp",
   "repository": "github:burggraf/pi-teams",
   "author": "Mark Burggraf",