pi-teams 0.9.13 → 0.9.14

package/extensions/index.ts

@@ -554,7 +554,7 @@ export default function (pi: ExtensionAPI) {
       prompt: Type.String(),
       cwd: Type.String(),
       model: Type.Optional(Type.String()),
-      thinking: Type.Optional(StringEnum(["off", "minimal", "low", "medium", "high"])),
+      thinking: Type.Optional(StringEnum(["off", "minimal", "low", "medium", "high", "xhigh"])),
       plan_mode_required: Type.Optional(Type.Boolean({ default: false })),
       separate_window: Type.Optional(Type.Boolean({ default: false })),
     }),

package/package.json

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

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

@@ -62,12 +62,16 @@ describe("CmuxAdapter", () => {
       process.env.CMUX_SOCKET_PATH = "/tmp/cmux.sock";
     });
 
-    it("should spawn a new pane and return the surface ID", () => {
-      mockExecCommand.mockReturnValue({ 
-        stdout: "OK surface-42", 
-        stderr: "", 
-        status: 0 
-      });
+    it("should spawn via new-split + poll + respawn-pane and return the new surface", () => {
+      mockExecCommand
+        // 1. listSurfaceRefs (before snapshot) — realistic cmux output
+        .mockReturnValueOnce({ stdout: "* surface:1  Terminal  [selected]\n  surface:2  Terminal\n", stderr: "", status: 0 })
+        // 2. new-split right
+        .mockReturnValueOnce({ stdout: "OK", stderr: "", status: 0 })
+        // 3. listSurfaceRefs (poll — finds new surface:42)
+        .mockReturnValueOnce({ stdout: "* surface:1  Terminal  [selected]\n  surface:2  Terminal\n  surface:42  Terminal\n", stderr: "", status: 0 })
+        // 4. respawn-pane
+        .mockReturnValueOnce({ stdout: "OK", stderr: "", status: 0 });
 
       const result = adapter.spawn({
         name: "test-agent",
@@ -76,19 +80,25 @@ describe("CmuxAdapter", () => {
         env: { PI_AGENT_ID: "test-123" },
       });
 
-      expect(result).toBe("surface-42");
-      expect(mockExecCommand).toHaveBeenCalledWith(
-        "cmux",
-        ["new-split", "right", "--command", "env PI_AGENT_ID=test-123 pi --agent test"]
-      );
+      expect(result).toBe("surface:42");
+
+      // Verify new-split was called without --command
+      expect(mockExecCommand).toHaveBeenCalledWith("cmux", ["new-split", "right"]);
+
+      // Verify respawn-pane was called with the new surface and full command
+      expect(mockExecCommand).toHaveBeenCalledWith("cmux", [
+        "respawn-pane",
+        "--surface", "surface:42",
+        "--command", "env PI_AGENT_ID=test-123 pi --agent test",
+      ]);
     });
 
     it("should spawn without env prefix when no PI_ vars", () => {
-      mockExecCommand.mockReturnValue({ 
-        stdout: "OK surface-99", 
-        stderr: "", 
-        status: 0 
-      });
+      mockExecCommand
+        .mockReturnValueOnce({ stdout: "  surface:1  Terminal\n", stderr: "", status: 0 })
+        .mockReturnValueOnce({ stdout: "OK", stderr: "", status: 0 })
+        .mockReturnValueOnce({ stdout: "  surface:1  Terminal\n  surface:99  Terminal\n", stderr: "", status: 0 })
+        .mockReturnValueOnce({ stdout: "OK", stderr: "", status: 0 });
 
       const result = adapter.spawn({
         name: "test-agent",
@@ -97,19 +107,20 @@ describe("CmuxAdapter", () => {
         env: { OTHER: "ignored" },
       });
 
-      expect(result).toBe("surface-99");
-      expect(mockExecCommand).toHaveBeenCalledWith(
-        "cmux",
-        ["new-split", "right", "--command", "pi"]
-      );
+      expect(result).toBe("surface:99");
+      expect(mockExecCommand).toHaveBeenCalledWith("cmux", [
+        "respawn-pane",
+        "--surface", "surface:99",
+        "--command", "pi",
+      ]);
     });
 
-    it("should throw on spawn failure", () => {
-      mockExecCommand.mockReturnValue({ 
-        stdout: "", 
-        stderr: "cmux not found", 
-        status: 1 
-      });
+    it("should throw on new-split failure", () => {
+      mockExecCommand
+        // listSurfaceRefs (before)
+        .mockReturnValueOnce({ stdout: "  surface:1  Terminal\n", stderr: "", status: 0 })
+        // new-split fails
+        .mockReturnValueOnce({ stdout: "", stderr: "cmux not found", status: 1 });
 
       expect(() => adapter.spawn({
         name: "test-agent",
@@ -119,19 +130,43 @@ describe("CmuxAdapter", () => {
       })).toThrow("cmux new-split failed with status 1");
     });
 
-    it("should throw on unexpected output format", () => {
-      mockExecCommand.mockReturnValue({ 
-        stdout: "ERROR something went wrong", 
-        stderr: "", 
-        status: 0 
-      });
+    it("should throw when new surface is not found after polling", () => {
+      mockExecCommand
+        // listSurfaceRefs (before)
+        .mockReturnValueOnce({ stdout: "  surface:1  Terminal\n", stderr: "", status: 0 })
+        // new-split OK
+        .mockReturnValueOnce({ stdout: "OK", stderr: "", status: 0 });
+
+      // All subsequent polls return the same surfaces (no new one appears)
+      // Each poll cycle = listSurfaceRefs + sleep
+      for (let i = 0; i < 20; i++) {
+        mockExecCommand
+          .mockReturnValueOnce({ stdout: "  surface:1  Terminal\n", stderr: "", status: 0 })  // listSurfaceRefs
+          .mockReturnValueOnce({ stdout: "", stderr: "", status: 0 });  // sleep
+      }
+
+      expect(() => adapter.spawn({
+        name: "test-agent",
+        cwd: "/home/user/project",
+        command: "pi",
+        env: {},
+      })).toThrow("new surface was not found");
+    });
+
+    it("should throw when respawn-pane fails", () => {
+      mockExecCommand
+        .mockReturnValueOnce({ stdout: "  surface:1  Terminal\n", stderr: "", status: 0 })
+        .mockReturnValueOnce({ stdout: "OK", stderr: "", status: 0 })
+        .mockReturnValueOnce({ stdout: "  surface:1  Terminal\n  surface:50  Terminal\n", stderr: "", status: 0 })
+        // respawn-pane fails
+        .mockReturnValueOnce({ stdout: "", stderr: "respawn error", status: 1 });
 
       expect(() => adapter.spawn({
         name: "test-agent",
         cwd: "/home/user/project",
         command: "pi",
         env: {},
-      })).toThrow("cmux new-split returned unexpected output");
+      })).toThrow("cmux respawn-pane failed with status 1");
     });
   });
 
@@ -306,4 +341,4 @@ describe("CmuxAdapter", () => {
       expect(adapter.isWindowAlive(undefined as unknown as string)).toBe(false);
     });
   });
-});
+});

package/src/adapters/cmux-adapter.ts

@@ -2,10 +2,20 @@
  * CMUX Terminal Adapter
  * 
  * Implements the TerminalAdapter interface for CMUX (cmux.dev).
+ *
+ * Spawn strategy: cmux's `new-split` does not support a `--command` flag.
+ * We follow the proven pattern from pi-cmux (npm:pi-cmux):
+ *   1. Snapshot existing surfaces
+ *   2. `cmux new-split <direction>`
+ *   3. Poll `cmux list-pane-surfaces` to find the newly created surface
+ *   4. `cmux respawn-pane --surface <id> --command <cmd>` to run the command
  */
 
 import { TerminalAdapter, SpawnOptions, execCommand } from "../utils/terminal-adapter";
 
+const SURFACE_POLL_ATTEMPTS = 20;
+const SURFACE_POLL_DELAY_MS = 150;
+
 export class CmuxAdapter implements TerminalAdapter {
   readonly name = "cmux";
 
@@ -18,34 +28,79 @@ export class CmuxAdapter implements TerminalAdapter {
     return !!process.env.CMUX_SOCKET_PATH || !!process.env.CMUX_WORKSPACE_ID;
   }
 
+  /**
+   * List all surface refs currently visible in the workspace.
+   */
+  private listSurfaceRefs(): Set<string> {
+    const refs = new Set<string>();
+    try {
+      const result = execCommand("cmux", ["list-pane-surfaces"]);
+      if (result.status === 0) {
+        for (const line of result.stdout.split("\n")) {
+          // Output lines look like: "* surface:5  ⠹ π · ziahmco  [selected]"
+          // Extract the surface:N ref from each line.
+          const match = line.match(/\b(surface:\d+)\b/);
+          if (match) refs.add(match[1]);
+        }
+      }
+    } catch {
+      // Ignore
+    }
+    return refs;
+  }
+
+  /**
+   * Block until a new surface appears that was not in `before`, or give up.
+   */
+  private waitForNewSurface(before: Set<string>): string | null {
+    for (let i = 0; i < SURFACE_POLL_ATTEMPTS; i++) {
+      const current = this.listSurfaceRefs();
+      for (const ref of current) {
+        if (!before.has(ref)) return ref;
+      }
+      // spawnSync-based sleep — keeps the adapter synchronous
+      execCommand("sleep", [String(SURFACE_POLL_DELAY_MS / 1000)]);
+    }
+    return null;
+  }
+
   spawn(options: SpawnOptions): string {
-    // We use new-split to create a new pane in CMUX.
-    // CMUX doesn't have a direct 'spawn' that returns a pane ID and runs a command 
-    // in one go while also returning the ID in a way we can easily capture for 'isAlive'.
-    // However, 'new-split' returns the new surface ID.
-    
-    // Construct the command with environment variables
+    // Construct the full command with PI_ environment variables
     const envPrefix = Object.entries(options.env)
       .filter(([k]) => k.startsWith("PI_"))
       .map(([k, v]) => `${k}=${v}`)
       .join(" ");
-    
+
     const fullCommand = envPrefix ? `env ${envPrefix} ${options.command}` : options.command;
 
-    // CMUX new-split returns "OK <UUID>"
-    const splitResult = execCommand("cmux", ["new-split", "right", "--command", fullCommand]);
-    
+    // 1. Snapshot existing surfaces before the split
+    const before = this.listSurfaceRefs();
+
+    // 2. Create the split (without --command, which is not supported)
+    const splitResult = execCommand("cmux", ["new-split", "right"]);
+
     if (splitResult.status !== 0) {
       throw new Error(`cmux new-split failed with status ${splitResult.status}: ${splitResult.stderr}`);
     }
 
-    const output = splitResult.stdout.trim();
-    if (output.startsWith("OK ")) {
-      const surfaceId = output.substring(3).trim();
-      return surfaceId;
+    // 3. Poll for the newly created surface
+    const newSurface = this.waitForNewSurface(before);
+    if (!newSurface) {
+      throw new Error("cmux new-split succeeded but new surface was not found");
+    }
+
+    // 4. Use respawn-pane to run the command in the new surface
+    const respawnResult = execCommand("cmux", [
+      "respawn-pane",
+      "--surface", newSurface,
+      "--command", fullCommand,
+    ]);
+
+    if (respawnResult.status !== 0) {
+      throw new Error(`cmux respawn-pane failed with status ${respawnResult.status}: ${respawnResult.stderr}`);
     }
 
-    throw new Error(`cmux new-split returned unexpected output: ${output}`);
+    return newSurface;
   }
 
   kill(paneId: string): void {

package/src/utils/models.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { THINKING_LEVELS } from "./models";
+
+describe("thinking levels", () => {
+  it("includes xhigh for teammate configuration", () => {
+    expect(THINKING_LEVELS).toContain("xhigh");
+  });
+});

package/src/utils/models.ts

@@ -1,3 +1,7 @@
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
 export interface Member {
   agentId: string;
   name: string;
@@ -10,7 +14,7 @@ export interface Member {
   subscriptions: any[];
   prompt?: string;
   color?: string;
-  thinking?: "off" | "minimal" | "low" | "medium" | "high";
+  thinking?: ThinkingLevel;
   planModeRequired?: boolean;
   backendType?: string;
   isActive?: boolean;

package/src/utils/predefined-teams.test.ts

@@ -11,6 +11,7 @@ import {
   getAllPredefinedTeams,
   getAgentDefinition,
   getPredefinedTeam,
+  saveTeamTemplate,
 } from "./predefined-teams";
 
 describe("parseAgentFrontmatter", () => {
@@ -256,7 +257,8 @@ full:
 
 describe("getAllAgentDefinitions and getAllPredefinedTeams", () => {
   const globalDir = path.join(os.homedir(), ".pi", "agent", "agents");
-  const globalTeamsDir = path.join(os.homedir(), ".pi", "agent");
+  const globalTeamsDir = path.join(os.homedir(), ".pi");
+  const legacyGlobalTeamsDir = path.join(os.homedir(), ".pi", "agent");
   const projectDir = path.join(os.tmpdir(), "pi-teams-test-project-" + Date.now());
   const projectAgentsDir = path.join(projectDir, ".pi", "agents");
   const projectTeamsDir = path.join(projectDir, ".pi");
@@ -264,6 +266,7 @@ describe("getAllAgentDefinitions and getAllPredefinedTeams", () => {
   // Store original files to restore later
   let originalGlobalAgents: string[] = [];
   let originalGlobalTeams: string | null = null;
+  let originalLegacyGlobalTeams: string | null = null;
 
   beforeEach(() => {
     // Create project directory
@@ -279,12 +282,31 @@ describe("getAllAgentDefinitions and getAllPredefinedTeams", () => {
     if (fs.existsSync(path.join(globalTeamsDir, "teams.yaml"))) {
       originalGlobalTeams = fs.readFileSync(path.join(globalTeamsDir, "teams.yaml"), "utf-8");
     }
+    if (fs.existsSync(path.join(legacyGlobalTeamsDir, "teams.yaml"))) {
+      originalLegacyGlobalTeams = fs.readFileSync(path.join(legacyGlobalTeamsDir, "teams.yaml"), "utf-8");
+    }
   });
 
   afterEach(() => {
     if (fs.existsSync(projectDir)) {
       fs.rmSync(projectDir, { recursive: true });
     }
+
+    const globalTeamsPath = path.join(globalTeamsDir, "teams.yaml");
+    if (originalGlobalTeams === null) {
+      if (fs.existsSync(globalTeamsPath)) fs.rmSync(globalTeamsPath);
+    } else {
+      fs.mkdirSync(globalTeamsDir, { recursive: true });
+      fs.writeFileSync(globalTeamsPath, originalGlobalTeams);
+    }
+
+    const legacyGlobalTeamsPath = path.join(legacyGlobalTeamsDir, "teams.yaml");
+    if (originalLegacyGlobalTeams === null) {
+      if (fs.existsSync(legacyGlobalTeamsPath)) fs.rmSync(legacyGlobalTeamsPath);
+    } else {
+      fs.mkdirSync(legacyGlobalTeamsDir, { recursive: true });
+      fs.writeFileSync(legacyGlobalTeamsPath, originalLegacyGlobalTeams);
+    }
   });
 
   it("combines global and project-local agents", () => {
@@ -330,6 +352,37 @@ custom:
     expect(result.find(t => t.name === "custom")).toBeDefined();
     expect(result.find(t => t.name === "custom")?.agents).toEqual(["agent1", "agent2"]);
   });
+
+  it("reads global predefined teams from ~/.pi/teams.yaml", () => {
+    fs.mkdirSync(globalTeamsDir, { recursive: true });
+    fs.writeFileSync(path.join(globalTeamsDir, "teams.yaml"), `
+root-global:
+  - scout
+`);
+
+    const result = getAllPredefinedTeams();
+
+    expect(result.find(t => t.name === "root-global")).toBeDefined();
+    expect(result.find(t => t.name === "root-global")?.agents).toEqual(["scout"]);
+  });
+
+  it("falls back to legacy ~/.pi/agent/teams.yaml when needed", () => {
+    const globalTeamsPath = path.join(globalTeamsDir, "teams.yaml");
+    if (fs.existsSync(globalTeamsPath)) {
+      fs.rmSync(globalTeamsPath);
+    }
+
+    fs.mkdirSync(legacyGlobalTeamsDir, { recursive: true });
+    fs.writeFileSync(path.join(legacyGlobalTeamsDir, "teams.yaml"), `
+legacy-global:
+  - scout
+`);
+
+    const result = getAllPredefinedTeams();
+
+    expect(result.find(t => t.name === "legacy-global")).toBeDefined();
+    expect(result.find(t => t.name === "legacy-global")?.agents).toEqual(["scout"]);
+  });
 });
 
 describe("getAgentDefinition and getPredefinedTeam", () => {
@@ -386,4 +439,73 @@ test-team:
     const result = getPredefinedTeam("non-existent", projectDir);
     expect(result).toBeUndefined();
   });
+});
+
+describe("saveTeamTemplate", () => {
+  const rootPiDir = path.join(os.homedir(), ".pi");
+  const globalAgentsDir = path.join(rootPiDir, "agent", "agents");
+  const globalTeamsPath = path.join(rootPiDir, "teams.yaml");
+  const projectDir = path.join(os.tmpdir(), "pi-teams-test-save-" + Date.now());
+
+  let originalGlobalTeams: string | null = null;
+  let originalAgentFiles = new Set<string>();
+
+  beforeEach(() => {
+    if (fs.existsSync(projectDir)) {
+      fs.rmSync(projectDir, { recursive: true });
+    }
+
+    if (fs.existsSync(globalTeamsPath)) {
+      originalGlobalTeams = fs.readFileSync(globalTeamsPath, "utf-8");
+    }
+    if (fs.existsSync(globalAgentsDir)) {
+      originalAgentFiles = new Set(fs.readdirSync(globalAgentsDir));
+    }
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(projectDir)) {
+      fs.rmSync(projectDir, { recursive: true });
+    }
+
+    if (originalGlobalTeams === null) {
+      if (fs.existsSync(globalTeamsPath)) fs.rmSync(globalTeamsPath);
+    } else {
+      fs.mkdirSync(path.dirname(globalTeamsPath), { recursive: true });
+      fs.writeFileSync(globalTeamsPath, originalGlobalTeams);
+    }
+
+    if (fs.existsSync(globalAgentsDir)) {
+      for (const file of fs.readdirSync(globalAgentsDir)) {
+        if (!originalAgentFiles.has(file)) {
+          fs.rmSync(path.join(globalAgentsDir, file));
+        }
+      }
+    }
+  });
+
+  it("writes user-scoped teams to ~/.pi/teams.yaml and agents to ~/.pi/agent/agents", () => {
+    const result = saveTeamTemplate(
+      {
+        name: "audit-team",
+        members: [
+          {
+            name: "security-worker",
+            agentType: "teammate",
+            prompt: "Audit security issues",
+          },
+        ],
+      },
+      {
+        templateName: "audit-team",
+        scope: "user",
+      }
+    );
+
+    expect(result.teamsYamlPath).toBe(globalTeamsPath);
+    expect(result.agentsDir).toBe(globalAgentsDir);
+    expect(fs.existsSync(globalTeamsPath)).toBe(true);
+    expect(fs.readFileSync(globalTeamsPath, "utf-8")).toContain("audit-team:");
+    expect(fs.existsSync(path.join(globalAgentsDir, "security-worker.md"))).toBe(true);
+  });
 });

package/src/utils/predefined-teams.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { ThinkingLevel } from "./models";
 
 /**
  * Represents an agent definition from a .md file
@@ -10,7 +11,7 @@ export interface AgentDefinition {
   description: string;
   tools?: string[];
   model?: string;
-  thinking?: "off" | "minimal" | "low" | "medium" | "high";
+  thinking?: ThinkingLevel;
   prompt: string;
   filePath: string;
 }
@@ -215,12 +216,18 @@ export function getAllPredefinedTeams(projectDir?: string): PredefinedTeam[] {
   const teams: PredefinedTeam[] = [];
   const seenNames = new Set<string>();
 
-  // Global teams
-  const globalDir = path.join(os.homedir(), ".pi", "agent");
-  for (const team of discoverTeams(globalDir)) {
-    if (!seenNames.has(team.name)) {
-      seenNames.add(team.name);
-      teams.push(team);
+  // Global teams: prefer the documented ~/.pi/teams.yaml location,
+  // but still fall back to the legacy ~/.pi/agent/teams.yaml path.
+  const globalDirs = [
+    path.join(os.homedir(), ".pi"),
+    path.join(os.homedir(), ".pi", "agent"),
+  ];
+  for (const globalDir of globalDirs) {
+    for (const team of discoverTeams(globalDir)) {
+      if (!seenNames.has(team.name)) {
+        seenNames.add(team.name);
+        teams.push(team);
+      }
     }
   }
 
@@ -293,7 +300,7 @@ export function generateAgentMarkdown(agent: {
   description?: string;
   tools?: string[];
   model?: string;
-  thinking?: "off" | "minimal" | "low" | "medium" | "high";
+  thinking?: ThinkingLevel;
   prompt?: string;
 }): string {
   const lines: string[] = ["---"];
@@ -387,7 +394,7 @@ export function saveTeamTemplate(
       name: string;
       agentType: string;
       model?: string;
-      thinking?: "off" | "minimal" | "low" | "medium" | "high";
+      thinking?: ThinkingLevel;
       prompt?: string;
     }>;
     defaultModel?: string;
@@ -395,12 +402,13 @@ export function saveTeamTemplate(
   options: SaveTeamTemplateOptions
 ): SaveTeamTemplateResult {
   // Determine output paths based on scope
-  const baseDir = options.scope === "project"
-    ? path.join(options.projectDir || process.cwd(), ".pi")
-    : path.join(os.homedir(), ".pi", "agent");
+  const agentsDir = options.scope === "project"
+    ? path.join(options.projectDir || process.cwd(), ".pi", "agents")
+    : path.join(os.homedir(), ".pi", "agent", "agents");
 
-  const agentsDir = path.join(baseDir, "agents");
-  const teamsYamlPath = path.join(baseDir, "teams.yaml");
+  const teamsYamlPath = options.scope === "project"
+    ? path.join(options.projectDir || process.cwd(), ".pi", "teams.yaml")
+    : path.join(os.homedir(), ".pi", "teams.yaml");
 
   // Ensure agents directory exists
   if (!fs.existsSync(agentsDir)) {