@pi-in-go/pigpen-acp 0.1.0

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

@@ -0,0 +1,421 @@
+package acp
+
+// Test helpers: the fakes of test/helpers/fakes.ts (FakeAgentSideConnection and
+// FakePiRpcProcess) and small assertions. The test files are named after the upstream
+// files they port; every twin keeps its upstream test name in a comment or subtest name.
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"sync"
+	"testing"
+	"time"
+)
+
+// sentUpdate is one session/update the fake connection received.
+type sentUpdate struct {
+	SessionID string
+	Update    Update
+}
+
+// fakeConn is FakeAgentSideConnection.
+type fakeConn struct {
+	mu                 sync.Mutex
+	updates            []sentUpdate
+	permissionRequests []PermissionRequest
+	nextPermission     PermissionResponse
+	// sessionUpdateHook, when set, runs inside SessionUpdate before the update is recorded.
+	sessionUpdateHook func(u Update)
+}
+
+func newFakeConn() *fakeConn {
+	return &fakeConn{nextPermission: PermissionResponse{Outcome: PermissionOutcome{Outcome: "selected", OptionID: "allow"}}}
+}
+
+func (c *fakeConn) SessionUpdate(sessionID string, update Update) error {
+	c.mu.Lock()
+	hook := c.sessionUpdateHook
+	c.mu.Unlock()
+	if hook != nil {
+		hook(update)
+	}
+	c.mu.Lock()
+	c.updates = append(c.updates, sentUpdate{sessionID, update})
+	c.mu.Unlock()
+	return nil
+}
+
+func (c *fakeConn) RequestPermission(req PermissionRequest) (PermissionResponse, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.permissionRequests = append(c.permissionRequests, req)
+	return c.nextPermission, nil
+}
+
+func (c *fakeConn) all() []sentUpdate {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return append([]sentUpdate(nil), c.updates...)
+}
+
+func (c *fakeConn) kinds() []string {
+	var out []string
+	for _, u := range c.all() {
+		out = append(out, str(u.Update["sessionUpdate"]))
+	}
+	return out
+}
+
+func (c *fakeConn) ofKind(kind string) []sentUpdate {
+	var out []sentUpdate
+	for _, u := range c.all() {
+		if u.Update["sessionUpdate"] == kind {
+			out = append(out, u)
+		}
+	}
+	return out
+}
+
+func (c *fakeConn) reset() {
+	c.mu.Lock()
+	c.updates = nil
+	c.mu.Unlock()
+}
+
+func (c *fakeConn) permissions() []PermissionRequest {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return append([]PermissionRequest(nil), c.permissionRequests...)
+}
+
+// fakeProc is FakePiRpcProcess. Tests override behavior through the func fields.
+type fakeProc struct {
+	mu       sync.Mutex
+	handlers []func(Event)
+
+	prompts              []promptCall
+	extensionUIResponses []map[string]any
+	abortCount           int
+	getSessionStatsCount int
+	disposed             int
+	disposeHook          func()
+
+	sessionStats      SessionStats
+	sessionStatsError error
+	statsTimeouts     []int
+
+	getStateFn         func() (map[string]any, error)
+	getModelsFn        func() (map[string]any, error)
+	getLevelsFn        func() ([]string, error)
+	getMessagesFn      func() (map[string]any, error)
+	getCommandsFn      func() (map[string]any, error)
+	setModelFn         func(provider, id string) error
+	setThinkingFn      func(level string) error
+	setSteeringFn      func(mode string) error
+	setFollowUpFn      func(mode string) error
+	setSessionNameFn   func(name string) error
+	compactFn          func(instr string) (map[string]any, error)
+	setAutoCompactFn   func(bool) error
+	exportHTMLFn       func(path string) (string, error)
+	getSessionStatsFn  func(timeoutMs int) (SessionStats, error)
+	promptErr          error
+	promptHook         func()
+	extensionUIRespErr error
+}
+
+type promptCall struct {
+	Message string
+	Images  []Image
+}
+
+func newFakeProc() *fakeProc { return &fakeProc{} }
+
+func (p *fakeProc) OnEvent(h func(Event)) func() {
+	p.mu.Lock()
+	p.handlers = append(p.handlers, h)
+	idx := len(p.handlers) - 1
+	p.mu.Unlock()
+	return func() {
+		p.mu.Lock()
+		defer p.mu.Unlock()
+		if idx < len(p.handlers) {
+			p.handlers[idx] = func(Event) {}
+		}
+	}
+}
+
+// emit delivers an event to every handler, synchronously, as FakePiRpcProcess.emit does.
+func (p *fakeProc) emit(ev Event) {
+	p.mu.Lock()
+	hs := append([]func(Event){}, p.handlers...)
+	p.mu.Unlock()
+	for _, h := range hs {
+		h(ev)
+	}
+}
+
+func (p *fakeProc) Prompt(message string, images []Image) error {
+	p.mu.Lock()
+	if images == nil {
+		images = []Image{}
+	}
+	p.prompts = append(p.prompts, promptCall{message, images})
+	err, hook := p.promptErr, p.promptHook
+	p.mu.Unlock()
+	if hook != nil {
+		hook()
+	}
+	return err
+}
+
+func (p *fakeProc) promptList() []promptCall {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return append([]promptCall(nil), p.prompts...)
+}
+
+func (p *fakeProc) Abort() error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	p.abortCount++
+	return nil
+}
+
+func (p *fakeProc) aborts() int {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return p.abortCount
+}
+
+func (p *fakeProc) SendExtensionUIResponse(resp map[string]any) error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	p.extensionUIResponses = append(p.extensionUIResponses, resp)
+	return p.extensionUIRespErr
+}
+
+func (p *fakeProc) uiResponses() []map[string]any {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return append([]map[string]any(nil), p.extensionUIResponses...)
+}
+
+func (p *fakeProc) GetState() (map[string]any, error) {
+	if p.getStateFn != nil {
+		return p.getStateFn()
+	}
+	return map[string]any{}, nil
+}
+
+func (p *fakeProc) GetAvailableModels() (map[string]any, error) {
+	if p.getModelsFn != nil {
+		return p.getModelsFn()
+	}
+	return map[string]any{"models": []any{map[string]any{"provider": "test", "id": "model", "name": "model"}}}, nil
+}
+
+func (p *fakeProc) GetAvailableThinkingLevels() ([]string, error) {
+	if p.getLevelsFn != nil {
+		return p.getLevelsFn()
+	}
+	return []string{"medium", "high"}, nil
+}
+
+func (p *fakeProc) GetMessages() (map[string]any, error) {
+	if p.getMessagesFn != nil {
+		return p.getMessagesFn()
+	}
+	return map[string]any{"messages": []any{}}, nil
+}
+
+func (p *fakeProc) GetCommands() (map[string]any, error) {
+	if p.getCommandsFn != nil {
+		return p.getCommandsFn()
+	}
+	return nil, fmt.Errorf("pi get_commands failed: unsupported")
+}
+
+func (p *fakeProc) GetSessionStats(timeoutMs int) (SessionStats, error) {
+	p.mu.Lock()
+	p.getSessionStatsCount++
+	p.statsTimeouts = append(p.statsTimeouts, timeoutMs)
+	fn, stats, err := p.getSessionStatsFn, p.sessionStats, p.sessionStatsError
+	p.mu.Unlock()
+	if fn != nil {
+		return fn(timeoutMs)
+	}
+	if err != nil {
+		return nil, err
+	}
+	if stats == nil {
+		stats = SessionStats{}
+	}
+	return stats, nil
+}
+
+func (p *fakeProc) statsCount() int {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return p.getSessionStatsCount
+}
+
+func (p *fakeProc) SetModel(provider, id string) error {
+	if p.setModelFn != nil {
+		return p.setModelFn(provider, id)
+	}
+	return nil
+}
+
+func (p *fakeProc) SetThinkingLevel(level string) error {
+	if p.setThinkingFn != nil {
+		return p.setThinkingFn(level)
+	}
+	return nil
+}
+
+func (p *fakeProc) SetSteeringMode(mode string) error {
+	if p.setSteeringFn != nil {
+		return p.setSteeringFn(mode)
+	}
+	return nil
+}
+
+func (p *fakeProc) SetFollowUpMode(mode string) error {
+	if p.setFollowUpFn != nil {
+		return p.setFollowUpFn(mode)
+	}
+	return nil
+}
+
+func (p *fakeProc) SetSessionName(name string) error {
+	if p.setSessionNameFn != nil {
+		return p.setSessionNameFn(name)
+	}
+	return nil
+}
+
+func (p *fakeProc) Compact(instr string) (map[string]any, error) {
+	if p.compactFn != nil {
+		return p.compactFn(instr)
+	}
+	return map[string]any{}, nil
+}
+
+func (p *fakeProc) SetAutoCompaction(enabled bool) error {
+	if p.setAutoCompactFn != nil {
+		return p.setAutoCompactFn(enabled)
+	}
+	return nil
+}
+
+func (p *fakeProc) ExportHTML(path string) (string, error) {
+	if p.exportHTMLFn != nil {
+		return p.exportHTMLFn(path)
+	}
+	return path, nil
+}
+
+func (p *fakeProc) Dispose() {
+	p.mu.Lock()
+	p.disposed++
+	hook := p.disposeHook
+	p.mu.Unlock()
+	if hook != nil {
+		hook()
+	}
+}
+
+func (p *fakeProc) disposeCount() int {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return p.disposed
+}
+
+// --- assertions ---
+
+func str(v any) string {
+	s, _ := v.(string)
+	return s
+}
+
+// norm round-trips a value through JSON, so a typed struct and a map literal compare equal.
+func norm(t testing.TB, v any) any {
+	t.Helper()
+	b, err := json.Marshal(v)
+	if err != nil {
+		t.Fatalf("marshal %v: %v", v, err)
+	}
+	var out any
+	if err := json.Unmarshal(b, &out); err != nil {
+		t.Fatalf("unmarshal %s: %v", b, err)
+	}
+	return out
+}
+
+// jsonEqual is assert.deepEqual over JSON values.
+func jsonEqual(t testing.TB, got, want any, msg ...any) {
+	t.Helper()
+	g, w := norm(t, got), norm(t, want)
+	if !reflect.DeepEqual(g, w) {
+		gb, _ := json.MarshalIndent(g, "", "  ")
+		wb, _ := json.MarshalIndent(w, "", "  ")
+		t.Fatalf("%v\n got: %s\nwant: %s", msg, gb, wb)
+	}
+}
+
+// eventually polls cond (the JS tests await a macrotask; the Go port runs turns on goroutines).
+func eventually(t testing.TB, what string, cond func() bool) {
+	t.Helper()
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if cond() {
+			return
+		}
+		time.Sleep(2 * time.Millisecond)
+	}
+	t.Fatalf("timed out waiting for %s", what)
+}
+
+// settle waits for the session's emit queue to drain: it publishes context usage on a session,
+// which flushes every queued update (used where the JS tests `await` a timer).
+func settle(t testing.TB, s *Session) {
+	t.Helper()
+	s.flushEmits()
+}
+
+// newTestSession is `new PiAcpSession({sessionId:'s1', cwd, mcpServers:[], proc, conn, fileCommands:[]})`.
+func newTestSession(cwd string, proc Proc, conn Conn, cmds ...FileSlashCommand) *Session {
+	return NewSession(SessionOptions{SessionID: "s1", Cwd: cwd, McpServers: []any{}, Proc: proc, Conn: conn, FileCommands: cmds})
+}
+
+func wait(t testing.TB, ch <-chan TurnResult) TurnResult {
+	t.Helper()
+	select {
+	case r := <-ch:
+		return r
+	case <-time.After(2 * time.Second):
+		t.Fatal("prompt turn did not finish")
+		return TurnResult{}
+	}
+}
+
+func settledTurn(proc *fakeProc) {
+	proc.emit(Event{"type": "agent_start"})
+	proc.emit(Event{"type": "turn_end"})
+	proc.emit(Event{"type": "agent_end"})
+	proc.emit(Event{"type": "agent_settled"})
+}
+
+func tmp(t testing.TB) string {
+	t.Helper()
+	return t.TempDir()
+}
+
+// promptsOf waits until pi has received n prompts: the session hands a prompt to pi on its own
+// goroutine, so a test that has only seen the turn settle cannot assume the call was recorded.
+func promptsOf(t testing.TB, p *fakeProc, n int) []promptCall {
+	t.Helper()
+	eventually(t, "the prompt to reach pi", func() bool { return len(p.promptList()) >= n })
+	return p.promptList()
+}

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

@@ -0,0 +1,28 @@
+package acp
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestMain isolates every test from the real configuration: HOME, PIG_HOME and the agent
+// directories point into a temporary directory, so nothing reads or writes ~/.pig.
+func TestMain(m *testing.M) {
+	root, err := os.MkdirTemp("", "pig-acp-test-*")
+	if err != nil {
+		panic(err)
+	}
+	for k, v := range map[string]string{
+		"HOME": filepath.Join(root, "home"), "PIG_HOME": filepath.Join(root, "pighome"),
+		"PIG_CODING_AGENT_DIR": filepath.Join(root, "agent"), "PI_CODING_AGENT_DIR": filepath.Join(root, "piagent"),
+		"XDG_CONFIG_HOME": filepath.Join(root, "xdg"), "PIG_USE_PI_DIRS": "", "PI_ACP_PI_COMMAND": "", "PIG_ACP_PIG_COMMAND": "",
+		"PI_ACP_ENABLE_EMBEDDED_CONTEXT": "", "PIG_ACP_ENABLE_EMBEDDED_CONTEXT": "",
+		"PIG_CODING_AGENT_SESSION_DIR": "", "PI_CODING_AGENT_SESSION_DIR": "",
+	} {
+		os.Setenv(k, v)
+	}
+	code := m.Run()
+	os.RemoveAll(root)
+	os.Exit(code)
+}

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

@@ -0,0 +1,142 @@
+package acp
+
+// Cases added after the first mutation run (port/mutations.json) showed that the ported twins left
+// a defect alive. They are not twins of upstream tests; each names the mutant it kills.
+
+import (
+	"errors"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func loadFixture(t *testing.T) (*Agent, *fakeConn, *memStore, *fakeSessions, *fakeProc, string) {
+	t.Helper()
+	cwd := cwdNow(t)
+	proc := newFakeProc()
+	proc.getStateFn = func() (map[string]any, error) { return map[string]any{"thinkingLevel": "medium"}, nil }
+	proc.getModelsFn = func() (map[string]any, error) { return map[string]any{"models": []any{}}, nil }
+	conn := newFakeConn()
+	a, _ := testAgent(conn)
+	store := newMemStore(StoredSession{SessionID: "s1", Cwd: cwd, SessionFile: "/tmp/s.jsonl"})
+	a.store = store
+	sessions := &fakeSessions{session: &fakeSession{id: "s1", cwd: cwd, proc: proc}, anyID: true}
+	a.sessions = sessions
+	return a, conn, store, sessions, proc, cwd
+}
+
+func TestMutationExtras(t *testing.T) {
+	t.Run("a session/new whose get_state fails with a credentials error is AUTH_REQUIRED [state-auth-error-ignored]", func(t *testing.T) {
+		proc := newFakeProc()
+		proc.getStateFn = func() (map[string]any, error) { return nil, errors.New("pi get_state failed: No API key found") }
+		a, _ := testAgent(newFakeConn())
+		a.sessions = &fakeSessions{session: &fakeSession{id: "s1", cwd: cwdNow(t), proc: proc}}
+		_, err := a.NewSession(newSessionReq(cwdNow(t)))
+		if re, ok := err.(*RequestError); !ok || re.Code != -32000 {
+			t.Fatalf("err = %v", err)
+		}
+	})
+
+	t.Run("session/load closes a live copy of the session first [load-does-not-close-live-copy]", func(t *testing.T) {
+		a, _, _, sessions, _, cwd := loadFixture(t)
+		if _, err := a.LoadSession(LoadSessionRequest{SessionID: "s1", Cwd: cwd}); err != nil {
+			t.Fatal(err)
+		}
+		if len(sessions.closeCalls) == 0 || sessions.closeCalls[0] != "s1" {
+			t.Errorf("closeCalls = %v", sessions.closeCalls)
+		}
+	})
+
+	t.Run("session/load refreshes the session map with the cwd it was loaded with [load-does-not-refresh-map]", func(t *testing.T) {
+		a, _, store, _, _, cwd := loadFixture(t)
+		if _, err := a.LoadSession(LoadSessionRequest{SessionID: "s1", Cwd: cwd}); err != nil {
+			t.Fatal(err)
+		}
+		if len(store.upserts) == 0 || store.upserts[len(store.upserts)-1] != (StoredSession{SessionID: "s1", Cwd: cwd, SessionFile: "/tmp/s.jsonl"}) {
+			t.Errorf("upserts = %+v", store.upserts)
+		}
+	})
+
+	t.Run("a replayed failed tool result is a failed tool_call_update [tool-history-not-replayed-as-error]", func(t *testing.T) {
+		a, conn, _, _, proc, cwd := loadFixture(t)
+		proc.getMessagesFn = func() (map[string]any, error) {
+			return map[string]any{"messages": []any{
+				map[string]any{"role": "toolResult", "toolCallId": "c1", "toolName": "read", "isError": true, "content": []any{map[string]any{"type": "text", "text": "no such file"}}}}}, nil
+		}
+		if _, err := a.LoadSession(LoadSessionRequest{SessionID: "s1", Cwd: cwd}); err != nil {
+			t.Fatal(err)
+		}
+		up := conn.ofKind("tool_call_update")
+		if len(up) != 1 || up[0].Update["status"] != "failed" {
+			t.Fatalf("updates = %+v", up)
+		}
+	})
+
+	t.Run("the idle notice reaches the client before the prompt result [idle-notice-not-flushed-before-response]", func(t *testing.T) {
+		conn, proc := newFakeConn(), newFakeProc()
+		conn.sessionUpdateHook = func(u Update) {
+			if u["sessionUpdate"] == "session_info_update" {
+				time.Sleep(60 * time.Millisecond)
+			}
+		}
+		s := newTestSession(cwdNow(t), proc, conn)
+		p := s.Prompt("hello", nil)
+		settledTurn(proc)
+		wait(t, p)
+		if n := len(conn.ofKind("session_info_update")); n != 2 {
+			t.Errorf("%d session_info_update at the moment the turn resolved, want 2", n)
+		}
+	})
+
+	t.Run("a select answer with a leading-zero option id is cancelled [select-index-leading-zero-accepted]", func(t *testing.T) {
+		conn, proc := newFakeConn(), newFakeProc()
+		conn.nextPermission = PermissionResponse{Outcome: PermissionOutcome{Outcome: "selected", OptionID: "choice-01"}}
+		newTestSession(cwdNow(t), proc, conn)
+		proc.emit(Event{"type": "extension_ui_request", "id": "u1", "method": "select", "title": "x", "options": []any{"A", "B"}})
+		eventually(t, "the response", func() bool { return len(proc.uiResponses()) == 1 })
+		jsonEqual(t, proc.uiResponses(), []any{map[string]any{"id": "u1", "cancelled": true}})
+	})
+
+	t.Run("session files are listed most recent first [sessions-oldest-first]", func(t *testing.T) {
+		root := t.TempDir()
+		withAgentDir(t, root)
+		for id, ts := range map[string]string{"old": "2026-01-01T00:00:00.000Z", "new": "2026-03-01T00:00:00.000Z", "mid": "2026-02-01T00:00:00.000Z"} {
+			writeSessionFile(t, filepath.Join(root, "sessions", "--x--", id+".jsonl"), sessionHeader(id, "/cwd", ts),
+				jl(map[string]any{"type": "message", "id": "m1", "timestamp": ts, "message": map[string]any{"role": "user", "content": "hi"}}))
+		}
+		var ids []string
+		for _, s := range ListPiSessions() {
+			ids = append(ids, s.SessionID)
+		}
+		if strings.Join(ids, ",") != "new,mid,old" {
+			t.Errorf("order = %v", ids)
+		}
+	})
+}
+
+func TestBase64ByteLength(t *testing.T) {
+	t.Run("byte lengths of padded base64 data [base64-length-padding]", func(t *testing.T) {
+		for in, want := range map[string]int{"": 0, "YQ==": 1, "YWI=": 2, "YWJj": 3, "YWJjZA==": 4} {
+			if got := base64ByteLength(in); got != want {
+				t.Errorf("%q: got %d, want %d", in, got, want)
+			}
+		}
+	})
+}
+
+func TestExportNeedsMessages(t *testing.T) {
+	t.Run("/export with a session file but no messages says there is nothing to export [export-empty-session-exported]", func(t *testing.T) {
+		file := filepath.Join(t.TempDir(), "s.jsonl")
+		write(t, file, "{\"type\":\"session\"}\n")
+		proc := newFakeProc()
+		proc.getStateFn = func() (map[string]any, error) {
+			return map[string]any{"sessionFile": file, "messageCount": 0}, nil
+		}
+		a, conn := builtinAgent(t, proc, cwdNow(t))
+		runCmd(t, a, "/export")
+		if got := lastChunkText(t, conn); !strings.HasPrefix(got, "Nothing to export yet (no session messages)") {
+			t.Errorf("text = %q", got)
+		}
+	})
+}

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

@@ -0,0 +1,77 @@
+package acp
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func sharedPiDirs() bool { return os.Getenv("PIG_USE_PI_DIRS") == "1" }
+
+func userHome() string {
+	if h, err := os.UserHomeDir(); err == nil && h != "" {
+		return h
+	}
+	return os.Getenv("HOME")
+}
+
+// expandTilde expands a leading "~" or "~/" as pig does for its directory variables
+// (internal/codingagent ExpandTildePath). An editor passes env values unexpanded.
+func expandTilde(p string) string {
+	if p == "~" {
+		return userHome()
+	}
+	if rest, ok := strings.CutPrefix(p, "~/"); ok {
+		return filepath.Join(userHome(), rest)
+	}
+	return p
+}
+
+// pigHome is PiG's config root: PIG_HOME, else XDG_CONFIG_HOME/pig, else ~/.pig. PiG keeps its own
+// state here even in shared mode (PIG_USE_PI_DIRS=1), which shares only the agent and project
+// directories with Pi.
+func pigHome() string {
+	if h := os.Getenv("PIG_HOME"); h != "" {
+		return expandTilde(h)
+	}
+	if x := os.Getenv("XDG_CONFIG_HOME"); x != "" {
+		return filepath.Join(expandTilde(x), "pig")
+	}
+	return filepath.Join(userHome(), ".pig")
+}
+
+// AgentDir is PiG's agent directory: PIG_CODING_AGENT_DIR, else <PIG_HOME>/agent; with
+// PIG_USE_PI_DIRS=1 it is Pi's (PI_CODING_AGENT_DIR, else ~/.pi/agent).
+func AgentDir() string {
+	if sharedPiDirs() {
+		if d := os.Getenv("PI_CODING_AGENT_DIR"); d != "" {
+			return absPath(expandTilde(d))
+		}
+		return filepath.Join(userHome(), ".pi", "agent")
+	}
+	if d := os.Getenv("PIG_CODING_AGENT_DIR"); d != "" {
+		return absPath(expandTilde(d))
+	}
+	return filepath.Join(pigHome(), "agent")
+}
+
+func absPath(p string) string {
+	if a, err := filepath.Abs(p); err == nil {
+		return a
+	}
+	return p
+}
+
+// ProjectDirName is ".pig", or ".pi" when PIG_USE_PI_DIRS=1.
+func ProjectDirName() string {
+	if sharedPiDirs() {
+		return ".pi"
+	}
+	return ".pig"
+}
+
+// AcpDir is where the adapter keeps its own state, apart from pig's agent directory.
+func AcpDir() string { return filepath.Join(pigHome(), "pig-acp") }
+
+// SessionMapPath is the file the default store uses.
+func SessionMapPath() string { return filepath.Join(AcpDir(), "session-map.json") }