feat: support Pi Desktop subagents and Selesai skills

.gitignore

@@ -6,6 +6,7 @@ __pycache__/
 # Canonical user-config runtime state
 external/
 dotagents.local.yaml
+/subagents/
 memsearch.conf
 .skill-lock.json
 

README.md

@@ -47,12 +47,16 @@ Five surfaces, each rendered into the harness's own format — dotagents does no
 | Qwen Code | yes, config-driven | yes | yes | yes | skills + MCP§ |
 | OMP (pi fork) | yes | yes | yes | --‡ | -- |
 | Pi* | yes | --* | --* | -- | -- |
+| Pi Desktop¶ | yes | yes | -- | -- | -- |
+| Selesai Code** | yes, filtered | -- | -- | -- | -- |
 
 \* Vanilla [pi](https://github.com/earendil-works/pi) is skills-only by design; the OMP fork is detected as its own target.
 † OpenCode reads `~/.agents/skills/` natively; its only hook surface is a JS plugin API.
 ‡ OMP has no managed hook surface yet; register memory hooks manually if needed.
 § Qwen Code natively loads Agent Plugins v1 skills and MCP servers; dotagents manages those same surfaces without rewriting the plugin.
 ⁑ Amp's hook and role surfaces use plugin-based models incompatible with dotagents' script-based hooks and per-agent role files.
+¶ Pi Desktop reads the supported global `~/.agents/skills` and `~/.agents/subagents` roots; MCP and other settings remain configured in the app's Settings UI.
+** [Selesai Code](https://github.com/SelesaiInTech/selesai-code) uses `~/.selesai/agent/skills`; dotagents syncs only non-bundled skills and reports conflicts instead of overwriting Selesai-owned names.
 
 OpenClaw is not currently supported. Native skill discovery from `~/.agents/skills` may work due to OpenClaw's multi-tier skill precedence, but this is unverified and unmanaged. A managed harness entry is planned for a future release. A "yes" above only appears after end-to-end verification.
 

cmd/dotagents/agents.go

@@ -439,6 +439,12 @@ func renderClaudeAgentRole(role agentRole) string {
 	return b.String()
 }
 
+// renderPiDesktopAgentRole emits the Markdown frontmatter consumed by
+// Pi Desktop's global ~/.agents/subagents directory.
+func renderPiDesktopAgentRole(role agentRole) string {
+	return renderClaudeAgentRole(role)
+}
+
 func renderCodexAgentRole(role agentRole) string {
 	model := strings.TrimSpace(role.Codex.Model)
 	if model == "" {

cmd/dotagents/doctor.go

@@ -23,8 +23,10 @@ const (
 	agentHermes              = "hermes"
 	agentOpenCode            = "opencode"
 	agentPi                  = "pi"
+	agentPiDesktop           = "pi-desktop"
 	agentOMP                 = "omp"
 	agentQwenCode            = "qwen-code"
+	agentSelesai             = "selesai"
 	dotagentsSkillsPathValue = "~/.agents/skills"
 )
 

cmd/dotagents/harness.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"os/exec"
 	"path/filepath"
 	"sort"
@@ -245,6 +246,13 @@ func initHarnesses() {
 			TrailerExample: "Co-authored-by: pi[bot] <pi[bot]@users.noreply.github.com>",
 		},
 
+		agentPiDesktop: {
+			Detect:          detectPiDesktop,
+			Skills:          SkillsSymlink,
+			Roles:           &RolesCapability{Extension: ".md", Render: renderPiDesktopAgentRole},
+			IntegrationNote: "uses Pi Desktop's supported global ~/.agents/skills and ~/.agents/subagents roots; no app internals or plugin package",
+		},
+
 		agentOMP: {
 			Skills: SkillsSymlink,
 			MCP: mcpTargetPtr(mcpTarget{
@@ -258,6 +266,13 @@ func initHarnesses() {
 			Roles: &RolesCapability{Extension: ".md", Render: renderOMPAgentRole},
 		},
 
+		agentSelesai: {
+			Detect:          detectSelesai,
+			Skills:          SkillsSymlink,
+			TrailerExample:  "Co-authored-by: selesai[bot] <selesai[bot]@users.noreply.github.com>",
+			IntegrationNote: "syncs only non-bundled skills to avoid conflicts with Selesai's installed bundled skills",
+		},
+
 		agentQwenCode: {
 			Skills: SkillsConfigDriven,
 			InspectSkills: func(agent agentConfig, expected map[string]string, agentsSkillRoot string, cfg config, home string) (agentReport, error) {
@@ -348,3 +363,16 @@ func detectVanillaPi(executable string) bool {
 	version, _ := exec.Command(executable, "--version").CombinedOutput() // nosemgrep: go.lang.security.audit.dangerous-exec-command
 	return !bytes.HasPrefix(bytes.TrimSpace(version), []byte("omp/"))
 }
+
+func detectPiDesktop(executable string) bool {
+	// Pi Desktop is a GUI application. Detect by checking if the app bundle exists.
+	// The executable might be 'pi' from the PATH, but we check for the desktop app.
+	info, err := os.Stat("/Applications/PI-Desktop.app")
+	return err == nil && info.IsDir()
+}
+
+func detectSelesai(executable string) bool {
+	// Verify this is actually the selesai command, not something else named 'selesai'.
+	version, _ := exec.Command(executable, "--version").CombinedOutput() // nosemgrep: go.lang.security.audit.dangerous-exec-command
+	return bytes.Contains(bytes.ToLower(version), []byte("selesai"))
+}

cmd/dotagents/inspect.go

@@ -77,7 +77,11 @@ func discoverLocalSkills(repoRoot string, _ string) ([]discoveredSkill, error) {
 	return discovered, nil
 }
 
-func expectedSkillsForAgent(base map[string]string, _ string, _ config, _ string) (map[string]string, error) {
+func expectedSkillsForAgent(base map[string]string, _ string, _ config, agentName string) (map[string]string, error) {
+	// Filter bundled skills for Selesai to avoid conflicts
+	if agentName == agentSelesai {
+		return filterSelesaiExpectedSkills(base)
+	}
 	return base, nil
 }
 

cmd/dotagents/main.go

@@ -121,6 +121,10 @@ type agentReport struct {
 
 func isDetected(agent agentConfig) bool {
 	if agent.Detect == "" {
+		// No executable required, but check harness-specific detection if available
+		if harness := harnessFor(agent.Name); harness != nil && harness.Detect != nil {
+			return harness.Detect("")
+		}
 		return true
 	}
 	executable, err := exec.LookPath(agent.Detect)

cmd/dotagents/pi_desktop_test.go

@@ -0,0 +1,78 @@
+package main
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+)
+
+func TestPiDesktopHarnessCapabilities(t *testing.T) {
+	piDesktop := harnessFor(agentPiDesktop)
+	if piDesktop == nil {
+		t.Fatal("Pi Desktop harness is not registered")
+	}
+	if piDesktop.Skills != SkillsSymlink {
+		t.Fatalf("Pi Desktop skills capability = %v, want symlink", piDesktop.Skills)
+	}
+	if piDesktop.Roles == nil || piDesktop.Roles.Extension != ".md" {
+		t.Fatalf("Pi Desktop roles capability = %#v, want Markdown roles", piDesktop.Roles)
+	}
+	if piDesktop.MCP != nil || piDesktop.Hooks != nil || piDesktop.RootInstructions != nil {
+		t.Fatal("Pi Desktop must expose only its verified skills and subagents surfaces")
+	}
+	if piDesktop.IntegrationNote == "" {
+		t.Fatal("Pi Desktop should document its native global roots")
+	}
+}
+
+func TestPiDesktopDefaultConfig(t *testing.T) {
+	for _, cfg := range defaultAgentConfigs() {
+		if cfg.Name != agentPiDesktop {
+			continue
+		}
+		if cfg.SkillRoot != "~/.agents/skills" || cfg.AgentRoot != "~/.agents/subagents" || cfg.Detect != "" {
+			t.Fatalf("Pi Desktop default config = %#v", cfg)
+		}
+		return
+	}
+	t.Fatal("Pi Desktop not found in default agent configs")
+}
+
+func TestPiDesktopRendersSupportedSubagentRole(t *testing.T) {
+	role := agentRole{
+		Name:         "researcher",
+		Description:  "Find reliable evidence",
+		Model:        "gpt-5.6-luna",
+		Tools:        []string{"read", "grep"},
+		Instructions: "Compare the sources.",
+	}
+	root := filepath.Join(t.TempDir(), ".agents", "subagents")
+	path, content, ok := renderAgentRole(role, agentConfig{Name: agentPiDesktop, AgentRoot: root})
+	if !ok {
+		t.Fatal("Pi Desktop role was not rendered")
+	}
+	if want := filepath.Join(root, "researcher.md"); path != want {
+		t.Fatalf("Pi Desktop role path = %q, want %q", path, want)
+	}
+	parts := strings.SplitN(content, "---\n", 3)
+	if len(parts) != 3 {
+		t.Fatalf("Pi Desktop role lacks YAML frontmatter:\n%s", content)
+	}
+	var frontmatter struct {
+		Name        string `yaml:"name"`
+		Description string `yaml:"description"`
+		Model       string `yaml:"model"`
+		Tools       string `yaml:"tools"`
+	}
+	if err := yaml.Unmarshal([]byte(parts[1]), &frontmatter); err != nil {
+		t.Fatalf("parse Pi Desktop role frontmatter: %v", err)
+	}
+	if frontmatter.Name != role.Name || frontmatter.Description != role.Description || frontmatter.Model != role.Model || frontmatter.Tools != "read, grep" {
+		t.Fatalf("Pi Desktop role frontmatter = %#v", frontmatter)
+	}
+	if !strings.Contains(parts[2], role.Instructions) {
+		t.Fatalf("Pi Desktop role dropped instructions:\n%s", content)
+	}
+}

cmd/dotagents/selesai.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+// getSelesaiBundledSkills discovers Selesai's bundled skills by inspecting
+// the installed npm package. Returns a set of bundled skill names to exclude
+// from dotagents sync.
+func getSelesaiBundledSkills() (map[string]struct{}, error) {
+	// Find selesai executable
+	selesaiPath, err := exec.LookPath("selesai")
+	if err != nil {
+		// Selesai not installed, return empty set
+		return make(map[string]struct{}), nil
+	}
+
+	// Resolve symlink if the executable is a symlink (common with npm global installs)
+	selesaiPath, err = filepath.EvalSymlinks(selesaiPath)
+	if err != nil {
+		return nil, err
+	}
+
+	// npm global installs typically have structure:
+	// /path/to/npm/prefix/lib/node_modules/@selesai/code/bin/selesai.js
+	// We need to find the package directory: /path/to/npm/prefix/lib/node_modules/@selesai/code
+	packageDir := selesaiPath
+	for {
+		parent := filepath.Dir(packageDir)
+		if parent == packageDir {
+			// Reached root without finding package.json
+			return nil, errors.New("could not find @selesai/code package directory")
+		}
+		packageJSON := filepath.Join(parent, "package.json")
+		if hasFile(packageJSON) {
+			packageDir = parent
+			break
+		}
+		packageDir = parent
+	}
+
+	// Look for bundled skills in dist/skills/ or src/skills/
+	bundled := make(map[string]struct{})
+	for _, skillsDir := range []string{
+		filepath.Join(packageDir, "dist", "skills"),
+		filepath.Join(packageDir, "src", "skills"),
+	} {
+		entries, err := os.ReadDir(skillsDir)
+		if errors.Is(err, fs.ErrNotExist) {
+			continue
+		}
+		if err != nil {
+			return nil, err
+		}
+		for _, entry := range entries {
+			if entry.IsDir() && hasFile(filepath.Join(skillsDir, entry.Name(), "SKILL.md")) {
+				bundled[entry.Name()] = struct{}{}
+			}
+		}
+	}
+
+	return bundled, nil
+}
+
+// filterSelesaiExpectedSkills removes bundled skills from the expected skills map
+// for Selesai agent to avoid conflicts with Selesai's built-in skills.
+func filterSelesaiExpectedSkills(expected map[string]string) (map[string]string, error) {
+	bundled, err := getSelesaiBundledSkills()
+	if err != nil {
+		return nil, err
+	}
+
+	if len(bundled) == 0 {
+		// No bundled skills found or Selesai not installed, sync all skills
+		return expected, nil
+	}
+
+	filtered := make(map[string]string)
+	for name, path := range expected {
+		if _, isBundled := bundled[name]; !isBundled {
+			filtered[name] = path
+		}
+	}
+
+	return filtered, nil
+}