@pi-in-go/pigpen-acp 0.1.0

package/extensions/acp/cmd/pig-acp/internal/acp/session_usage_test.go

@@ -0,0 +1,198 @@
+package acp
+
+// Twins of the usage_update tests in test/component/session-events.test.ts, and of
+// test/component/session-queue-cancel.test.ts, session-slash-commands.test.ts.
+
+import (
+	"errors"
+	"math"
+	"testing"
+	"time"
+)
+
+func usageUpdates(c *fakeConn) []Update {
+	var out []Update
+	for _, u := range c.ofKind("usage_update") {
+		out = append(out, u.Update)
+	}
+	return out
+}
+
+func TestSessionUsage(t *testing.T) {
+	tw(t, "component/session-events", "PiAcpSession: emits usage_update from contextUsage before resolving prompt on agent_settled", func(t *testing.T) {
+		conn, proc := newFakeConn(), newFakeProc()
+		proc.sessionStats = SessionStats{"tokens": map[string]any{"total": 999999}, "contextUsage": map[string]any{"tokens": 12345, "contextWindow": 200000}}
+		s := newTestSession(cwdNow(t), proc, conn)
+		started := make(chan struct{})
+		release := make(chan struct{})
+		conn.sessionUpdateHook = func(u Update) {
+			if u["sessionUpdate"] == "usage_update" {
+				close(started)
+				<-release
+			}
+		}
+		p := s.Prompt("hello", nil)
+		proc.emit(Event{"type": "agent_start"})
+		proc.emit(Event{"type": "agent_end"})
+		proc.emit(Event{"type": "agent_settled"})
+		select {
+		case <-started:
+		case <-time.After(5 * time.Second):
+			t.Fatal("usage_update delivery never started")
+		}
+		select {
+		case <-p:
+			t.Fatal("prompt resolved before usage_update landed")
+		case <-time.After(50 * time.Millisecond):
+		}
+		close(release)
+		if r := wait(t, p); r.Reason != StopEndTurn {
+			t.Fatalf("reason = %v", r)
+		}
+		if proc.statsCount() != 1 {
+			t.Errorf("get_session_stats called %d times", proc.statsCount())
+		}
+		jsonEqual(t, usageUpdates(conn), []Update{{"sessionUpdate": "usage_update", "used": 12345, "size": 200000}})
+	})
+
+	tw(t, "component/session-events", "PiAcpSession: skips usage_update when contextUsage tokens are null", func(t *testing.T) {
+		conn, proc := newFakeConn(), newFakeProc()
+		proc.sessionStats = SessionStats{"tokens": map[string]any{"total": 4000}, "contextUsage": map[string]any{"tokens": nil, "contextWindow": 200000}}
+		s := newTestSession(cwdNow(t), proc, conn)
+		p := s.Prompt("hello", nil)
+		proc.emit(Event{"type": "agent_settled"})
+		if r := wait(t, p); r.Reason != StopEndTurn {
+			t.Fatalf("reason = %v", r)
+		}
+		if len(usageUpdates(conn)) != 0 {
+			t.Error("usage_update emitted for null tokens")
+		}
+	})
+
+	tw(t, "component/session-events", "PiAcpSession: skips usage_update for invalid contextUsage values", func(t *testing.T) {
+		invalid := []struct {
+			name  string
+			usage any
+		}{
+			{"missing contextUsage", nil},
+			{"negative tokens", map[string]any{"tokens": -1, "contextWindow": 100}},
+			{"fractional tokens", map[string]any{"tokens": 1.5, "contextWindow": 100}},
+			{"NaN tokens", map[string]any{"tokens": math.NaN(), "contextWindow": 100}},
+			{"zero contextWindow", map[string]any{"tokens": 10, "contextWindow": 0}},
+			{"negative contextWindow", map[string]any{"tokens": 10, "contextWindow": -1}},
+			{"fractional contextWindow", map[string]any{"tokens": 10, "contextWindow": 100.5}},
+			{"null contextWindow", map[string]any{"tokens": 10, "contextWindow": nil}},
+			{"infinite contextWindow", map[string]any{"tokens": 10, "contextWindow": math.Inf(1)}},
+		}
+		for _, tc := range invalid {
+			conn, proc := newFakeConn(), newFakeProc()
+			stats := SessionStats{}
+			if tc.usage != nil {
+				stats["contextUsage"] = tc.usage
+			}
+			proc.sessionStats = stats
+			s := newTestSession(cwdNow(t), proc, conn)
+			p := s.Prompt("hello", nil)
+			proc.emit(Event{"type": "agent_settled"})
+			if r := wait(t, p); r.Reason != StopEndTurn {
+				t.Fatalf("%s: reason = %v", tc.name, r)
+			}
+			if len(usageUpdates(conn)) != 0 {
+				t.Errorf("%s: usage_update emitted", tc.name)
+			}
+		}
+	})
+
+	tw(t, "component/session-events", "PiAcpSession: get_session_stats rejection does not break the prompt", func(t *testing.T) {
+		conn, proc := newFakeConn(), newFakeProc()
+		proc.sessionStatsError = errors.New("pi get_session_stats failed: unsupported")
+		s := newTestSession(cwdNow(t), proc, conn)
+		p := s.Prompt("hello", nil)
+		proc.emit(Event{"type": "agent_settled"})
+		if r := wait(t, p); r.Reason != StopEndTurn {
+			t.Fatalf("reason = %v", r)
+		}
+		if proc.statsCount() != 1 || len(usageUpdates(conn)) != 0 {
+			t.Errorf("stats=%d updates=%v", proc.statsCount(), usageUpdates(conn))
+		}
+	})
+
+	tw(t, "component/session-events", "PiAcpSession: get_session_stats timeout does not block the prompt", func(t *testing.T) {
+		conn, proc := newFakeConn(), newFakeProc()
+		// The timeout lives in Process.Request; the session sees it as an error.
+		proc.sessionStatsError = errors.New("pi get_session_stats timed out after 1000ms")
+		s := newTestSession(cwdNow(t), proc, conn)
+		p := s.Prompt("hello", nil)
+		proc.emit(Event{"type": "agent_settled"})
+		if r := wait(t, p); r.Reason != StopEndTurn {
+			t.Fatalf("reason = %v", r)
+		}
+		if proc.statsCount() != 1 || len(usageUpdates(conn)) != 0 {
+			t.Errorf("stats=%d updates=%v", proc.statsCount(), usageUpdates(conn))
+		}
+	})
+
+	tw(t, "component/session-events", "PiAcpSession: cancelled turn still reports cancelled after usage publish", func(t *testing.T) {
+		conn, proc := newFakeConn(), newFakeProc()
+		proc.sessionStats = SessionStats{"contextUsage": map[string]any{"tokens": 42, "contextWindow": 100}}
+		s := newTestSession(cwdNow(t), proc, conn)
+		p := s.Prompt("hello", nil)
+		if err := s.Cancel(); err != nil {
+			t.Fatal(err)
+		}
+		proc.emit(Event{"type": "agent_settled"})
+		if r := wait(t, p); r.Reason != StopCancelled {
+			t.Fatalf("reason = %v", r)
+		}
+		jsonEqual(t, usageUpdates(conn), []Update{{"sessionUpdate": "usage_update", "used": 42, "size": 100}})
+	})
+}
+
+// test/component/session-queue-cancel.test.ts
+func TestSessionQueueCancel(t *testing.T) {
+	tw(t, "component/session-queue-cancel", "PiAcpSession: cancel clears queued prompts", func(t *testing.T) {
+		conn, proc := newFakeConn(), newFakeProc()
+		s := newTestSession(cwdNow(t), proc, conn)
+		first := s.Prompt("one", nil)
+		second := s.Prompt("two", nil)
+		third := s.Prompt("three", nil)
+		eventually(t, "the first prompt", func() bool { return len(proc.promptList()) == 1 })
+		if err := s.Cancel(); err != nil {
+			t.Fatal(err)
+		}
+		if proc.aborts() != 1 {
+			t.Errorf("abort count = %d", proc.aborts())
+		}
+		if r := wait(t, second); r.Reason != StopCancelled {
+			t.Errorf("second = %v", r)
+		}
+		if r := wait(t, third); r.Reason != StopCancelled {
+			t.Errorf("third = %v", r)
+		}
+		settledTurn(proc)
+		if r := wait(t, first); r.Reason != StopCancelled {
+			t.Errorf("first = %v", r)
+		}
+		// The queue was cleared, so no further prompt starts.
+		time.Sleep(20 * time.Millisecond)
+		if n := len(promptsOf(t, proc, 1)); n != 1 {
+			t.Errorf("%d prompts reached pi", n)
+		}
+	})
+}
+
+// test/component/session-slash-commands.test.ts
+func TestSessionSlashCommands(t *testing.T) {
+	tw(t, "component/session-slash-commands", "PiAcpSession: expands /command before sending to pi", func(t *testing.T) {
+		conn, proc := newFakeConn(), newFakeProc()
+		s := newTestSession(cwdNow(t), proc, conn, FileSlashCommand{Name: "hello", Description: "(user)", Content: "Expanded $1", Source: "(user)"})
+		p := s.Prompt("/hello world", nil)
+		settledTurn(proc)
+		if r := wait(t, p); r.Reason != StopEndTurn {
+			t.Fatalf("reason = %v", r)
+		}
+		if got := promptsOf(t, proc, 1); len(got) != 1 || got[0].Message != "Expanded world" {
+			t.Fatalf("prompts = %v", got)
+		}
+	})
+}

package/extensions/acp/cmd/pig-acp/internal/acp/settings.go

@@ -0,0 +1,79 @@
+package acp
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+)
+
+func readJSONObject(path string) map[string]any {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return map[string]any{}
+	}
+	var data any
+	if json.Unmarshal(raw, &data) != nil {
+		return map[string]any{}
+	}
+	if m, ok := data.(map[string]any); ok {
+		return m
+	}
+	return map[string]any{}
+}
+
+func deepMerge(a, b map[string]any) map[string]any {
+	out := make(map[string]any, len(a)+len(b))
+	for k, v := range a {
+		out[k] = v
+	}
+	for k, v := range b {
+		av, aok := out[k].(map[string]any)
+		bv, bok := v.(map[string]any)
+		if aok && bok {
+			out[k] = deepMerge(av, bv)
+		} else {
+			out[k] = v
+		}
+	}
+	return out
+}
+
+// mergedSettings mirrors pig's settings: the global file, overridden by the project file.
+func mergedSettings(cwd string) map[string]any {
+	global := readJSONObject(filepath.Join(AgentDir(), "settings.json"))
+	project := readJSONObject(filepath.Join(absPathFrom(cwd), ProjectDirName(), "settings.json"))
+	return deepMerge(global, project)
+}
+
+func absPathFrom(cwd string) string {
+	if filepath.IsAbs(cwd) {
+		return filepath.Clean(cwd)
+	}
+	return absPath(cwd)
+}
+
+// GetEnableSkillCommands reads enableSkillCommands from the merged PiG settings.
+func GetEnableSkillCommands(cwd string) bool {
+	m := mergedSettings(cwd)
+	if b, ok := m["enableSkillCommands"].(bool); ok {
+		return b
+	}
+	if skills, ok := m["skills"].(map[string]any); ok {
+		if b, ok := skills["enableSkillCommands"].(bool); ok {
+			return b
+		}
+	}
+	return true
+}
+
+// GetQuietStartup reads quietStartup from the merged PiG settings.
+func GetQuietStartup(cwd string) bool {
+	m := mergedSettings(cwd)
+	if b, ok := m["quietStartup"].(bool); ok {
+		return b
+	}
+	if b, ok := m["quietStart"].(bool); ok {
+		return b
+	}
+	return false
+}

package/extensions/acp/cmd/pig-acp/internal/acp/slash.go

@@ -0,0 +1,278 @@
+package acp
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// FileSlashCommand is a prompt template file used as a slash command.
+type FileSlashCommand struct {
+	Name        string
+	Description string
+	Content     string
+	Source      string // "(user)", "(project)", "(project:frontend)"
+}
+
+// AvailableCommand is an ACP available command.
+type AvailableCommand struct {
+	Name        string         `json:"name"`
+	Description string         `json:"description"`
+	Input       map[string]any `json:"input,omitempty"`
+}
+
+var frontmatterLine = regexp.MustCompile(`^(\w+):\s*(.*)$`)
+
+func parseFrontmatter(content string) (map[string]string, string) {
+	fm := map[string]string{}
+	if !strings.HasPrefix(content, "---") {
+		return fm, content
+	}
+	end := strings.Index(content[3:], "\n---")
+	if end == -1 {
+		return fm, content
+	}
+	end += 3
+	block := ""
+	if len(content) >= 4 {
+		block = content[4:end]
+	}
+	remaining := jsTrim(content[end+4:])
+	for _, line := range strings.Split(block, "\n") {
+		if m := frontmatterLine.FindStringSubmatch(line); m != nil {
+			fm[m[1]] = jsTrim(m[2])
+		}
+	}
+	return fm, remaining
+}
+
+func loadCommandsFromDir(dir, source, subdir string) []FileSlashCommand {
+	var commands []FileSlashCommand
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil
+	}
+	for _, e := range entries {
+		full := filepath.Join(dir, e.Name())
+		isDir, isFile := e.IsDir(), e.Type().IsRegular()
+		if e.Type()&os.ModeSymlink != 0 {
+			if st, err := os.Stat(full); err == nil {
+				isDir, isFile = st.IsDir(), st.Mode().IsRegular()
+			}
+		}
+		if isDir {
+			sub := e.Name()
+			if subdir != "" {
+				sub = subdir + ":" + e.Name()
+			}
+			commands = append(commands, loadCommandsFromDir(full, source, sub)...)
+			continue
+		}
+		if !isFile || !strings.HasSuffix(e.Name(), ".md") {
+			continue
+		}
+		raw, err := os.ReadFile(full)
+		if err != nil {
+			continue
+		}
+		fm, content := parseFrontmatter(string(raw))
+		name := strings.TrimSuffix(e.Name(), ".md")
+		src := "(" + source + ")"
+		if subdir != "" {
+			src = "(" + source + ":" + subdir + ")"
+		}
+		desc := fm["description"]
+		if desc == "" {
+			for _, l := range strings.Split(content, "\n") {
+				if jsTrim(l) != "" {
+					desc = truncateRunes(l, 60)
+					if len([]rune(l)) > 60 {
+						desc += "..."
+					}
+					break
+				}
+			}
+		}
+		if desc != "" {
+			desc += " " + src
+		} else {
+			desc = src
+		}
+		commands = append(commands, FileSlashCommand{Name: name, Description: desc, Content: content, Source: src})
+	}
+	return commands
+}
+
+// LoadSlashCommands loads user then project prompt templates:
+// <agent dir>/prompts and <cwd>/.pig/prompts.
+func LoadSlashCommands(cwd string) []FileSlashCommand {
+	var commands []FileSlashCommand
+	commands = append(commands, loadCommandsFromDir(filepath.Join(AgentDir(), "prompts"), "user", "")...)
+	commands = append(commands, loadCommandsFromDir(filepath.Join(absPathFrom(cwd), ProjectDirName(), "prompts"), "project", "")...)
+	return commands
+}
+
+// ToAvailableCommands converts file commands, de-duplicating by name (first wins).
+func ToAvailableCommands(cmds []FileSlashCommand) []AvailableCommand {
+	seen := map[string]bool{}
+	out := []AvailableCommand{}
+	for _, c := range cmds {
+		if seen[c.Name] {
+			continue
+		}
+		seen[c.Name] = true
+		out = append(out, AvailableCommand{Name: c.Name, Description: c.Description})
+	}
+	return out
+}
+
+// ParseCommandArgs splits arguments with bash-style quotes.
+func ParseCommandArgs(s string) []string {
+	var args []string
+	var cur strings.Builder
+	var quote rune
+	for _, ch := range s {
+		if quote != 0 {
+			if ch == quote {
+				quote = 0
+			} else {
+				cur.WriteRune(ch)
+			}
+			continue
+		}
+		switch {
+		case ch == '"' || ch == '\'':
+			quote = ch
+		case ch == ' ' || ch == '\t':
+			if cur.Len() > 0 {
+				args = append(args, cur.String())
+				cur.Reset()
+			}
+		default:
+			cur.WriteRune(ch)
+		}
+	}
+	if cur.Len() > 0 {
+		args = append(args, cur.String())
+	}
+	return args
+}
+
+var digitsRE = regexp.MustCompile(`\$(\d+)`)
+
+// SubstituteArgs replaces $1.. and $@.
+func SubstituteArgs(content string, args []string) string {
+	result := strings.ReplaceAll(content, "$@", strings.Join(args, " "))
+	return digitsRE.ReplaceAllStringFunc(result, func(m string) string {
+		n, err := strconv.Atoi(m[1:])
+		if err != nil || n-1 < 0 || n-1 >= len(args) {
+			return ""
+		}
+		return args[n-1]
+	})
+}
+
+// ExpandSlashCommand expands a leading /command that names a file command.
+func ExpandSlashCommand(text string, cmds []FileSlashCommand) string {
+	if !strings.HasPrefix(text, "/") {
+		return text
+	}
+	space := strings.Index(text, " ")
+	name, argStr := text[1:], ""
+	if space != -1 {
+		name, argStr = text[1:space], text[space+1:]
+	}
+	for _, c := range cmds {
+		if c.Name == name {
+			return SubstituteArgs(c.Content, ParseCommandArgs(argStr))
+		}
+	}
+	return text
+}
+
+// MergeCommands keeps order and de-duplicates by name (first wins).
+func MergeCommands(a, b []AvailableCommand) []AvailableCommand {
+	seen := map[string]bool{}
+	out := []AvailableCommand{}
+	for _, list := range [][]AvailableCommand{a, b} {
+		for _, c := range list {
+			if seen[c.Name] {
+				continue
+			}
+			seen[c.Name] = true
+			out = append(out, c)
+		}
+	}
+	return out
+}
+
+// PiCommandsOptions select which `get_commands` entries are advertised.
+type PiCommandsOptions struct {
+	EnableSkillCommands      bool
+	IncludeExtensionCommands bool
+}
+
+func describeFallback(c map[string]any) string {
+	var parts []string
+	if s, _ := c["source"].(string); s != "" {
+		parts = append(parts, s)
+	}
+	if s, _ := c["location"].(string); s != "" {
+		parts = append(parts, s)
+	}
+	if len(parts) == 0 {
+		return "(command)"
+	}
+	return "(" + strings.Join(parts, ":") + ")"
+}
+
+// ToAvailableCommandsFromPiGetCommands converts `get_commands` data.
+func ToAvailableCommandsFromPiGetCommands(data any, opts PiCommandsOptions) []AvailableCommand {
+	root := asObject(data)
+	raw, ok := root["commands"].([]any)
+	if !ok {
+		raw, _ = asObject(root["data"])["commands"].([]any)
+	}
+	out := []AvailableCommand{}
+	for _, item := range raw {
+		c := asObject(item)
+		name := ""
+		if s, ok := c["name"].(string); ok {
+			name = jsTrim(s)
+		}
+		if name == "" {
+			continue
+		}
+		if src, _ := c["source"].(string); !opts.IncludeExtensionCommands && src == "extension" {
+			continue
+		}
+		if !opts.EnableSkillCommands && strings.HasPrefix(name, "skill:") {
+			continue
+		}
+		desc := ""
+		if s, ok := c["description"].(string); ok {
+			desc = jsTrim(s)
+		}
+		if desc == "" {
+			desc = describeFallback(c)
+		}
+		out = append(out, AvailableCommand{Name: name, Description: desc})
+	}
+	return out
+}
+
+// BuiltinAvailableCommands are the commands the adapter handles itself; they never reach the model.
+func BuiltinAvailableCommands() []AvailableCommand {
+	return []AvailableCommand{
+		{Name: "compact", Description: "Manually compact the session context", Input: map[string]any{"hint": "optional custom instructions"}},
+		{Name: "autocompact", Description: "Toggle automatic context compaction", Input: map[string]any{"hint": "on|off|toggle"}},
+		{Name: "export", Description: "Export session to an HTML file in the session cwd"},
+		{Name: "session", Description: "Show session stats (messages, tokens, cost, session file)"},
+		{Name: "name", Description: "Set session display name", Input: map[string]any{"hint": "<name>"}},
+		{Name: "steering", Description: "Get/set pig steering message delivery mode (how queued steering messages are delivered)", Input: map[string]any{"hint": "(no args to show) all | one-at-a-time"}},
+		{Name: "follow-up", Description: "Get/set pig follow-up message delivery mode (how queued follow-up messages are delivered)", Input: map[string]any{"hint": "(no args to show) all | one-at-a-time"}},
+		{Name: "changelog", Description: "Show pig changelog"},
+	}
+}

package/extensions/acp/cmd/pig-acp/internal/acp/slash_test.go

@@ -0,0 +1,128 @@
+package acp
+
+// Twins of test/unit/slash-commands.test.ts, merge-commands.test.ts, pi-commands.test.ts,
+// builtin command lists, and auth-methods-terminal-auth-meta.test.ts.
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSlashCommands(t *testing.T) {
+	tw(t, "unit/slash-commands", "parseCommandArgs: handles quotes", func(t *testing.T) {
+		for in, want := range map[string][]string{"a b": {"a", "b"}, "'a b' c": {"a b", "c"}, `"a b" c`: {"a b", "c"}} {
+			if got := ParseCommandArgs(in); !reflect.DeepEqual(got, want) {
+				t.Errorf("%q: got %q, want %q", in, got, want)
+			}
+		}
+	})
+	tw(t, "unit/slash-commands", "substituteArgs: replaces $1.. and $@", func(t *testing.T) {
+		if got := SubstituteArgs("x=$1 y=$2 all=$@", []string{"one", "two"}); got != "x=one y=two all=one two" {
+			t.Errorf("got %q", got)
+		}
+		if got := SubstituteArgs("$3", []string{"one"}); got != "" {
+			t.Errorf("got %q", got)
+		}
+	})
+	tw(t, "unit/slash-commands", "expandSlashCommand: expands known command", func(t *testing.T) {
+		cmds := []FileSlashCommand{{Name: "hello", Description: "(user)", Content: "Say hi to $1", Source: "(user)"}}
+		for in, want := range map[string]string{"/hello world": "Say hi to world", "/unknown world": "/unknown world", "not a command": "not a command"} {
+			if got := ExpandSlashCommand(in, cmds); got != want {
+				t.Errorf("%q: got %q, want %q", in, got, want)
+			}
+		}
+	})
+	tw(t, "unit/slash-commands", "toAvailableCommands: de-dupes by name (first wins)", func(t *testing.T) {
+		got := ToAvailableCommands([]FileSlashCommand{
+			{Name: "x", Description: "first", Content: "1", Source: "(user)"},
+			{Name: "x", Description: "second", Content: "2", Source: "(project)"}})
+		jsonEqual(t, got, []any{map[string]any{"name": "x", "description": "first"}})
+	})
+	tw(t, "unit/merge-commands", "mergeCommands: preserves order and de-dupes (first wins)", func(t *testing.T) {
+		mk := func(names ...string) []AvailableCommand {
+			var out []AvailableCommand
+			for _, n := range names {
+				out = append(out, AvailableCommand{Name: n})
+			}
+			return out
+		}
+		got := MergeCommands(mk("a", "b"), mk("b", "c"))
+		var names []string
+		for _, c := range got {
+			names = append(names, c.Name)
+		}
+		if !reflect.DeepEqual(names, []string{"a", "b", "c"}) {
+			t.Errorf("got %v", names)
+		}
+	})
+	tw(t, "unit/pi-commands", "toAvailableCommandsFromPiGetCommands: hides extension commands by default and filters skill commands", func(t *testing.T) {
+		data := map[string]any{"commands": []any{
+			map[string]any{"name": "x", "description": "X", "source": "extension"},
+			map[string]any{"name": "skill:foo", "description": "Foo", "source": "skill", "location": "user"},
+			map[string]any{"name": "y", "source": "prompt", "location": "project"},
+		}}
+		all := ToAvailableCommandsFromPiGetCommands(data, PiCommandsOptions{EnableSkillCommands: true})
+		jsonEqual(t, all, []any{
+			map[string]any{"name": "skill:foo", "description": "Foo"},
+			map[string]any{"name": "y", "description": "(prompt:project)"},
+		})
+		withExt := ToAvailableCommandsFromPiGetCommands(data, PiCommandsOptions{EnableSkillCommands: true, IncludeExtensionCommands: true})
+		jsonEqual(t, withExt, []any{
+			map[string]any{"name": "x", "description": "X"},
+			map[string]any{"name": "skill:foo", "description": "Foo"},
+			map[string]any{"name": "y", "description": "(prompt:project)"},
+		})
+		noSkills := ToAvailableCommandsFromPiGetCommands(data, PiCommandsOptions{EnableSkillCommands: false})
+		jsonEqual(t, noSkills, []any{map[string]any{"name": "y", "description": "(prompt:project)"}})
+	})
+	t.Run("builtin commands are the eight the adapter handles itself", func(t *testing.T) {
+		var names []string
+		for _, c := range BuiltinAvailableCommands() {
+			names = append(names, c.Name)
+		}
+		want := []string{"compact", "autocompact", "export", "session", "name", "steering", "follow-up", "changelog"}
+		if !reflect.DeepEqual(names, want) {
+			t.Errorf("got %v, want %v", names, want)
+		}
+	})
+}
+
+func TestAuthMethods(t *testing.T) {
+	tw(t, "unit/auth-methods-terminal-auth-meta", "getAuthMethods: includes Zed terminal-auth metadata when enabled", func(t *testing.T) {
+		methods := AuthMethods(true)
+		if len(methods) != 1 {
+			t.Fatalf("%d methods", len(methods))
+		}
+		m := methods[0]
+		if m["id"] != PiSetupMethodID {
+			t.Errorf("id = %v", m["id"])
+		}
+		meta, _ := m["_meta"].(map[string]any)
+		ta, _ := meta["terminal-auth"].(map[string]any)
+		if ta == nil {
+			t.Fatal("no terminal-auth metadata")
+		}
+		if _, ok := ta["command"].(string); !ok {
+			t.Errorf("command = %v", ta["command"])
+		}
+		jsonEqual(t, ta["args"], []any{"--terminal-login"})
+		if ta["label"] != "Launch pig" {
+			t.Errorf("label = %v", ta["label"])
+		}
+		if m["type"] != "terminal" {
+			t.Errorf("type = %v", m["type"])
+		}
+		jsonEqual(t, m["args"], []any{"--terminal-login"})
+	})
+	tw(t, "unit/auth-methods-terminal-auth-meta", "getAuthMethods: omits Zed terminal-auth metadata when disabled", func(t *testing.T) {
+		methods := AuthMethods(false)
+		if len(methods) != 1 {
+			t.Fatalf("%d methods", len(methods))
+		}
+		m := methods[0]
+		meta, _ := m["_meta"].(map[string]any)
+		if _, ok := meta["terminal-auth"]; ok {
+			t.Error("terminal-auth present")
+		}
+	})
+}