pi-teams 0.7.3 → 0.8.5

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, iTerm2, or Zellij.
+**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 in Action
 
@@ -8,6 +8,8 @@
 | :---: | :---: | :---: |
 | <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)*
+
 ## 🛠 Installation
 
 Open your Pi terminal and type:
@@ -43,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).
@@ -56,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."
 
@@ -87,9 +102,9 @@ Teammates in `planning` mode will use `task_submit_plan`. As the lead, review th
 - **[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
+## 🪟 Terminal Requirements
 
-To show multiple agents on one screen, **pi-teams** requires a way to manage terminal panes. It supports **tmux**, **Zellij**, and **iTerm2** (macOS).
+To show multiple agents on one screen, **pi-teams** requires a way to manage terminal panes. It supports **tmux**, **Zellij**, **iTerm2**, and **WezTerm**.
 
 ### Option 1: tmux (Recommended)
 
@@ -109,7 +124,26 @@ 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. Like iTerm2, it supports both **Panes** and **Separate OS Windows**.
+
+Install WezTerm:
+- **macOS**: `brew install --cask wezterm`
+- **Linux**: See [wezterm.org/installation](https://wezterm.org/installation)
+- **Windows**: Download from [wezterm.org](https://wezterm.org)
+
+How to run:
+```bash
+wezterm  # Start WezTerm
+pi       # Start pi inside WezTerm
+```
 
 ## 📜 Credits & Attribution
 

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,8 +1,11 @@
 {
   "name": "pi-teams",
-  "version": "0.7.3",
+  "version": "0.8.5",
   "description": "Agent teams for pi, ported from claude-code-teams-mcp",
-  "repository": "github:burggraf/pi-teams",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/burggraf/pi-teams.git"
+  },
   "author": "Mark Burggraf",
   "license": "MIT",
   "keywords": [