@pi-in-go/pigpen-ahp 0.1.0

package/extensions/ahp/internal/pi/completions_test.go

@@ -0,0 +1,272 @@
+package pi_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"testing"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/host"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pi"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/testkit"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+// Twins of upstream test/completions.test.ts: inline completions for a message being composed.
+
+const completionsChat = "ahp-chat:/completions"
+
+func TestMentionParsing(t *testing.T) {
+	twin.Run(t, "completions", "finds a mention the cursor sits in", func(t *testing.T) {
+		got, ok := pi.FindMention("look at @foo", 12)
+		if !ok || got != (pi.Mention{Start: 8, End: 12, Query: "foo"}) {
+			t.Fatalf("got %+v %v", got, ok)
+		}
+	})
+	twin.Run(t, "completions", "finds a bare mention at the start of the text", func(t *testing.T) {
+		if got, ok := pi.FindMention("@src", 4); !ok || got.Query != "src" {
+			t.Fatalf("got %+v %v", got, ok)
+		}
+	})
+	twin.Run(t, "completions", "ignores an `@` that is not preceded by whitespace", func(t *testing.T) {
+		// Otherwise every email address and decorator opens the picker.
+		if _, ok := pi.FindMention("mail me at a@b.com", 18); ok {
+			t.Fatal("an email address opened the picker")
+		}
+	})
+	twin.Run(t, "completions", "ignores a cursor that is past the end of the mention", func(t *testing.T) {
+		if _, ok := pi.FindMention("@foo bar", 8); ok {
+			t.Fatal("the cursor is past the mention")
+		}
+	})
+	twin.Run(t, "completions", "returns the empty query for a lone trigger", func(t *testing.T) {
+		if got, ok := pi.FindMention("@", 1); !ok || got.Query != "" {
+			t.Fatalf("got %+v %v", got, ok)
+		}
+	})
+}
+
+func touch(t *testing.T, path string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte("x"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func complete(t *testing.T, s *pi.CompletionService, text string, offset int) ahptypes.CompletionsResult {
+	t.Helper()
+	r, err := s.Complete(context.Background(), ahptypes.CompletionsParams{Kind: ahptypes.CompletionItemKindUserMessage, Channel: completionsChat, Text: text, Offset: int64(offset)})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return r
+}
+
+func inserted(r ahptypes.CompletionsResult) []string {
+	out := []string{}
+	for _, i := range r.Items {
+		out = append(out, i.InsertText)
+	}
+	return out
+}
+
+func TestCompletions(t *testing.T) {
+	workspace := t.TempDir()
+	for _, f := range []string{"readme.md", "report.txt", "other.js", ".hidden", "src/index.ts", "src/lib/deep.ts", "node_modules/reactive.js", "dist/generated.js", "build/artifact.js"} {
+		touch(t, filepath.Join(workspace, f))
+	}
+	service := pi.NewCompletionService(pi.CompletionServiceOptions{WorkingDirectoryFor: func(string) string { return workspace }})
+	at := func(text string) ahptypes.CompletionsResult { return complete(t, service, text, len([]rune(text))) }
+
+	twin.Run(t, "completions", "offers files matching the typed prefix", func(t *testing.T) {
+		got := inserted(at("look at @re"))
+		sort.Strings(got)
+		sameJSON(t, got, []string{"@readme.md", "@report.txt"}, "insert texts")
+	})
+
+	twin.Run(t, "completions", "attaches the resource each item refers to", func(t *testing.T) {
+		r := at("@readme")
+		if len(r.Items) == 0 {
+			t.Fatal("no items")
+		}
+		att, ok := r.Items[0].Attachment.Value.(*ahptypes.MessageResourceAttachment)
+		if !ok || att.Type != ahptypes.MessageAttachmentKindResource || att.Label != "readme.md" || !regexp.MustCompile(`readme\.md$`).MatchString(att.Uri) {
+			t.Fatalf("attachment = %+v", r.Items[0].Attachment.Value)
+		}
+		testkit.AssertValid(t, "commands", "CompletionItem", r.Items[0])
+	})
+
+	twin.Run(t, "completions", "marks the range the client should replace", func(t *testing.T) {
+		r := at("look at @re")
+		// The span covers the `@` through the cursor, so accepting replaces the half-typed mention
+		// rather than appending to it.
+		if *r.Items[0].RangeStart != 8 || *r.Items[0].RangeEnd != 11 {
+			t.Fatalf("range = %d..%d", *r.Items[0].RangeStart, *r.Items[0].RangeEnd)
+		}
+	})
+
+	twin.Run(t, "completions", "returns nested files instead of directory navigation items", func(t *testing.T) {
+		r := at("@sr")
+		sameJSON(t, inserted(r), []string{"@src/index.ts", "@src/lib/deep.ts"}, "insert texts")
+		for _, i := range r.Items {
+			if k := i.Attachment.Value.(*ahptypes.MessageResourceAttachment).DisplayKind; k == nil || *k != "document" {
+				t.Fatalf("displayKind = %v", k)
+			}
+		}
+	})
+
+	twin.Run(t, "completions", "matches a typed relative-path prefix", func(t *testing.T) {
+		sameJSON(t, inserted(at("@src/in")), []string{"@src/index.ts"}, "insert texts")
+	})
+
+	twin.Run(t, "completions", "matches a nested file by basename", func(t *testing.T) {
+		sameJSON(t, inserted(at("@deep")), []string{"@src/lib/deep.ts"}, "insert texts")
+	})
+
+	twin.Run(t, "completions", "keeps the temporary directory skip list narrow", func(t *testing.T) {
+		got := inserted(at("@"))
+		has := func(s string) bool {
+			for _, g := range got {
+				if g == s {
+					return true
+				}
+			}
+			return false
+		}
+		for _, g := range got {
+			if regexp.MustCompile(`node_modules|\.hidden`).MatchString(g) {
+				t.Fatalf("offered %s", g)
+			}
+		}
+		if !has("@dist/generated.js") || !has("@build/artifact.js") {
+			t.Fatalf("build output must be offered: %v", got)
+		}
+	})
+
+	twin.Run(t, "completions", "does not interpret a query as path traversal", func(t *testing.T) {
+		if got := at("@../../etc/pass").Items; len(got) != 0 {
+			t.Fatalf("items = %v", got)
+		}
+	})
+
+	twin.Run(t, "completions", "returns nothing for a completion kind it does not implement", func(t *testing.T) {
+		r, err := service.Complete(context.Background(), ahptypes.CompletionsParams{Kind: "futureKind", Channel: completionsChat, Text: "@not", Offset: 4})
+		if err != nil || len(r.Items) != 0 {
+			t.Fatalf("items = %v (%v)", r.Items, err)
+		}
+	})
+
+	twin.Run(t, "completions", "returns nothing when the cursor is not in a mention", func(t *testing.T) {
+		if got := at("plain text").Items; len(got) != 0 {
+			t.Fatalf("items = %v", got)
+		}
+	})
+
+	twin.Run(t, "completions", "returns nothing for a chat it has no directory for", func(t *testing.T) {
+		orphan := pi.NewCompletionService(pi.CompletionServiceOptions{WorkingDirectoryFor: func(string) string { return "" }})
+		if got := complete(t, orphan, "@re", 3).Items; len(got) != 0 {
+			t.Fatalf("items = %v", got)
+		}
+	})
+
+	twin.Run(t, "completions", "caps how many items it returns", func(t *testing.T) {
+		crowded := t.TempDir()
+		for i := 0; i < 40; i++ {
+			touch(t, filepath.Join(crowded, fmt.Sprintf("file-%d.txt", i)))
+		}
+		capped := pi.NewCompletionService(pi.CompletionServiceOptions{WorkingDirectoryFor: func(string) string { return crowded }, MaxItems: 5})
+		if got := len(complete(t, capped, "@file", 5).Items); got != 5 {
+			t.Fatalf("%d items", got)
+		}
+	})
+}
+
+func TestCompletionsOverTheWire(t *testing.T) {
+	workspace := t.TempDir()
+	touch(t, filepath.Join(workspace, "notes.md"))
+	h := testkit.NewHost(host.Options{CompletionTriggerCharacters: []string{pi.MentionTrigger}})
+	h.Serve(host.Capabilities{Completions: pi.NewCompletionService(pi.CompletionServiceOptions{
+		WorkingDirectoryFor: func(channel string) string {
+			if channel == completionsChat {
+				return workspace
+			}
+			return ""
+		},
+	})})
+	client := testkit.Connect(t, h)
+	t.Cleanup(client.Close)
+	initialization := client.Initialize("completions-client", nil)
+	params := func(channel string) obj {
+		p := obj{"kind": "userMessage", "text": "@not", "offset": 4}
+		if channel != "" {
+			p["channel"] = channel
+		}
+		return p
+	}
+
+	twin.Run(t, "completions", "advertises only the trigger it can answer", func(t *testing.T) {
+		// "/" is deliberately absent: Pi's slash commands attach nothing, and every completion
+		// item must carry an attachment.
+		sameJSON(t, initialization.CompletionTriggerCharacters, []string{"@"}, "triggers")
+		testkit.AssertValid(t, "commands", "InitializeResult", initialization)
+	})
+
+	twin.Run(t, "completions", "serves a schema-conforming result", func(t *testing.T) {
+		p := params(completionsChat)
+		p["text"], p["offset"] = "see @not", 8
+		raw := client.Must("completions", p)
+		var result struct{ Items []obj }
+		if err := json.Unmarshal(raw, &result); err != nil {
+			t.Fatal(err)
+		}
+		if len(result.Items) != 1 || result.Items[0]["insertText"] != "@notes.md" {
+			t.Fatalf("result = %s", raw)
+		}
+		testkit.AssertValid(t, "commands", "CompletionsResult", testkit.Normalize(t, raw))
+	})
+
+	twin.Run(t, "completions", "rejects non-chat completion targets", func(t *testing.T) {
+		for _, channel := range []string{"", "ahp-session:/completions"} {
+			client.ExpectError("completions", params(channel), wire.CodeInvalidParams)
+		}
+	})
+
+	twin.Run(t, "completions", "maps provider-alias completion targets onto the default chat", func(t *testing.T) {
+		vscode := testkit.Connect(t, h)
+		t.Cleanup(vscode.Close)
+		vscode.Initialize("vscode-completions-client", obj{"clientInfo": obj{"name": "vscode-editor-window"}})
+		for _, c := range []*testkit.Client{vscode, client} {
+			var result struct{ Items []obj }
+			c.Decode(c.Must("completions", params("pi:/completions")), &result)
+			if len(result.Items) != 1 || result.Items[0]["insertText"] != "@notes.md" {
+				t.Fatalf("result = %v", result.Items)
+			}
+		}
+	})
+}
+
+func TestCompletionsWithoutAHandler(t *testing.T) {
+	twin.Run(t, "completions", "answers with an empty list rather than MethodNotFound", func(t *testing.T) {
+		// The client debounces keystrokes into this call; an error per keypress would be worse
+		// than nothing to show.
+		h := testkit.NewHost(host.Options{})
+		client := testkit.Connect(t, h)
+		t.Cleanup(client.Close)
+		client.Initialize("bare-client", nil)
+		var result struct{ Items []obj }
+		client.Decode(client.Must("completions", obj{"kind": "userMessage", "channel": completionsChat, "text": "@x", "offset": 2}), &result)
+		if len(result.Items) != 0 {
+			t.Fatalf("items = %v", result.Items)
+		}
+	})
+}

package/extensions/ahp/internal/pi/config_test.go

@@ -0,0 +1,269 @@
+package pi_test
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/host"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pi"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/testkit"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+// Twins of upstream test/project-trust.test.ts and test/session-config.test.ts.
+//
+// Project trust is a security default, not a convenience: Pi's SDK trusts a working directory
+// unless told otherwise, and a host takes that directory from a client over the network.
+
+func projectWithResources(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	// A project-level extension is exactly the thing trust gates: loading it executes code from
+	// the directory.
+	if err := os.MkdirAll(filepath.Join(dir, ".pi", "extensions"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, ".pi", "extensions", "ext.ts"), []byte("export default () => {};\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return dir
+}
+
+func resolveTrust(t *testing.T, cwd string, policy pi.ProjectTrustPolicy, agentDir string) pi.TrustDecision {
+	t.Helper()
+	// An isolated HOME so a developer's own ~/.agents/skills cannot leak into the result.
+	t.Setenv("HOME", t.TempDir())
+	d, err := pi.ResolveProjectTrust(cwd, policy, agentDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return d
+}
+
+func TestProjectTrust(t *testing.T) {
+	bare, withResources := t.TempDir(), projectWithResources(t)
+	agentDir := func() string { return t.TempDir() } // every policy case starts without a recorded decision
+	tp := func(b bool) *bool { return &b }
+
+	twin.Run(t, "project-trust", "trusts by default, matching raw pi SDK construction", func(t *testing.T) {
+		if got := resolveTrust(t, withResources, "", agentDir()); got != (pi.TrustDecision{Trusted: true, Reason: "policy"}) {
+			t.Fatalf("got %+v", got)
+		}
+	})
+
+	twin.Run(t, "project-trust", "trusts a directory with nothing to gate", func(t *testing.T) {
+		if got := resolveTrust(t, bare, pi.TrustPolicyInherit, agentDir()); got != (pi.TrustDecision{Trusted: true, Reason: "no-project-resources"}) {
+			t.Fatalf("got %+v", got)
+		}
+	})
+
+	twin.Run(t, "project-trust", "declines a project nobody has approved, under `inherit`", func(t *testing.T) {
+		// The important case: the SDK's own default would return true here.
+		if got := resolveTrust(t, withResources, pi.TrustPolicyInherit, agentDir()); got != (pi.TrustDecision{Trusted: false, Reason: "unknown-project"}) {
+			t.Fatalf("got %+v", got)
+		}
+	})
+
+	twin.Run(t, "project-trust", "inherits a decision the user made with pi's CLI", func(t *testing.T) {
+		dir := agentDir()
+		if err := pi.NewProjectTrustStore(dir).Set(withResources, tp(true)); err != nil {
+			t.Fatal(err)
+		}
+		// Reusing Pi's store means trusting once covers both tools, and revoking in either
+		// revokes in both.
+		if got := resolveTrust(t, withResources, pi.TrustPolicyInherit, dir); got != (pi.TrustDecision{Trusted: true, Reason: "user-trusted"}) {
+			t.Fatalf("got %+v", got)
+		}
+	})
+
+	twin.Run(t, "project-trust", "honours an explicit distrust from pi's CLI", func(t *testing.T) {
+		dir := agentDir()
+		if err := pi.NewProjectTrustStore(dir).Set(withResources, tp(false)); err != nil {
+			t.Fatal(err)
+		}
+		if got := resolveTrust(t, withResources, pi.TrustPolicyInherit, dir); got != (pi.TrustDecision{Trusted: false, Reason: "user-untrusted"}) {
+			t.Fatalf("got %+v", got)
+		}
+	})
+
+	twin.Run(t, "project-trust", "the `never` policy overrides a stored trust decision", func(t *testing.T) {
+		dir := agentDir()
+		if err := pi.NewProjectTrustStore(dir).Set(withResources, tp(true)); err != nil {
+			t.Fatal(err)
+		}
+		if got := resolveTrust(t, withResources, pi.TrustPolicyNever, dir); got != (pi.TrustDecision{Trusted: false, Reason: "policy"}) {
+			t.Fatalf("got %+v", got)
+		}
+	})
+
+	twin.Skip(t, "project-trust", "applies the decision before pi loads project extensions",
+		"needs an embedded Pi that loads project extensions from a client-chosen directory; this host serves the live PiG session only and never loads extensions itself (see PORT.md)")
+}
+
+func TestResolveSessionConfig(t *testing.T) {
+	bare, withResources := t.TempDir(), projectWithResources(t)
+	t.Setenv("HOME", t.TempDir())
+	service := pi.NewSessionConfigService(pi.SessionConfigOptions{DefaultWorkingDirectory: bare, AgentDir: t.TempDir()})
+	resolve := func(p ahptypes.ResolveSessionConfigParams) ahptypes.ResolveSessionConfigResult {
+		t.Helper()
+		r, err := service.Resolve(context.Background(), p)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return r
+	}
+	dir := func(path string) *string { u := wire.PathToFileURI(path); return &u }
+
+	twin.Run(t, "session-config", "returns a schema-conforming result", func(t *testing.T) {
+		testkit.AssertValid(t, "commands", "ResolveSessionConfigResult", resolve(ahptypes.ResolveSessionConfigParams{Channel: wire.RootChannel}))
+	})
+
+	twin.Run(t, "session-config", "reports what a directory with no project resources would do", func(t *testing.T) {
+		result := resolve(ahptypes.ResolveSessionConfigParams{Channel: wire.RootChannel, WorkingDirectory: dir(bare)})
+		if string(result.Values[pi.ProjectTrustKey]) != "true" {
+			t.Fatalf("values = %v", result.Values)
+		}
+		if p := result.Schema.Properties[pi.ProjectTrustKey]; p.ReadOnly == nil || !*p.ReadOnly {
+			t.Fatalf("property = %+v", p)
+		}
+	})
+
+	twin.Run(t, "session-config", "re-resolves against whatever directory the client is asking about", func(t *testing.T) {
+		// The exchange is iterative: the answer changes as the user picks a directory, which is
+		// the whole reason the command exists.
+		a := resolve(ahptypes.ResolveSessionConfigParams{Channel: wire.RootChannel, WorkingDirectory: dir(bare)})
+		b := resolve(ahptypes.ResolveSessionConfigParams{Channel: wire.RootChannel, WorkingDirectory: dir(withResources)})
+		if *a.Schema.Properties[pi.ProjectTrustKey].Description == *b.Schema.Properties[pi.ProjectTrustKey].Description {
+			t.Fatal("the description must change with the directory")
+		}
+	})
+
+	twin.Run(t, "session-config", "offers no dynamic completions", func(t *testing.T) {
+		result, err := service.Completions(context.Background(), ahptypes.SessionConfigCompletionsParams{Channel: wire.RootChannel, Property: pi.ProjectTrustKey})
+		if err != nil || len(result.Items) != 0 {
+			t.Fatalf("items = %v (%v)", result.Items, err)
+		}
+	})
+}
+
+// selectionBackend records the model selection each turn ran with.
+type selectionBackend struct {
+	*recordingBackend
+	mu2        chan struct{}
+	selections []ahptypes.ModelSelection
+	current    ahptypes.ModelSelection
+}
+
+func newSelectionBackend() *selectionBackend {
+	return &selectionBackend{
+		recordingBackend: &recordingBackend{}, mu2: make(chan struct{}, 1),
+		current: ahptypes.ModelSelection{Id: "default-model", Config: map[string]json.RawMessage{pi.ThinkingConfigKey: json.RawMessage(`"medium"`)}},
+	}
+}
+
+func (b *selectionBackend) SelectModel(_ context.Context, s ahptypes.ModelSelection) error {
+	b.recordingBackend.mu.Lock()
+	defer b.recordingBackend.mu.Unlock()
+	b.selections = append(b.selections, s)
+	b.current = s
+	return nil
+}
+
+func (b *selectionBackend) CurrentSelection() *ahptypes.ModelSelection {
+	b.recordingBackend.mu.Lock()
+	defer b.recordingBackend.mu.Unlock()
+	c := b.current
+	return &c
+}
+
+func (b *selectionBackend) selectionCount() int {
+	b.recordingBackend.mu.Lock()
+	defer b.recordingBackend.mu.Unlock()
+	return len(b.selections)
+}
+
+func TestModelSelection(t *testing.T) {
+	backend := newSelectionBackend()
+	h := testkit.NewHost(host.Options{})
+	reg := pi.NewRegistry(pi.RegistryOptions{
+		Host: h, CreateSessionManager: pi.InMemoryStorage,
+		CreateBackend: func(*pi.LiveSession) (pi.Backend, error) { return backend, nil },
+		// The backend is authoritative once it starts, including config values.
+		DefaultSelection: func() *ahptypes.ModelSelection {
+			return &ahptypes.ModelSelection{Id: "default-model", Config: map[string]json.RawMessage{pi.ThinkingConfigKey: json.RawMessage(`"low"`)}}
+		},
+	})
+	h.Serve(host.Capabilities{Sessions: reg})
+	client := testkit.Connect(t, h)
+	t.Cleanup(client.Close)
+	client.Initialize("model-client", nil)
+	id := newID()
+	chat := wire.ChatURI(id)
+	client.Must("createSession", obj{"channel": wire.SessionURI(id)})
+	client.Subscribe(chat)
+	draft := func() *ahptypes.Message { return h.Store().Chat(chat).Draft }
+	testkit.Eventually(t, "the backend model to reach the chat draft", func() bool {
+		d := draft()
+		return d != nil && d.Model != nil && d.Model.Id == "default-model" && string(d.Model.Config[pi.ThinkingConfigKey]) == `"medium"`
+	})
+
+	twin.Run(t, "session-config", "has a model selected before the agent has even started", func(t *testing.T) {
+		// Starting an agent takes seconds. A client that subscribes in the meantime would
+		// otherwise find an empty picker and be unable to send.
+		h2 := testkit.NewHost(host.Options{})
+		registry := pi.NewRegistry(pi.RegistryOptions{
+			Host: h2, CreateSessionManager: pi.InMemoryStorage,
+			DefaultSelection: func() *ahptypes.ModelSelection {
+				return &ahptypes.ModelSelection{Id: "seeded-model", Config: map[string]json.RawMessage{pi.ThinkingConfigKey: json.RawMessage(`"medium"`)}}
+			},
+		})
+		id := newID()
+		if err := registry.Create(context.Background(), ahptypes.CreateSessionParams{Channel: wire.SessionURI(id)}); err != nil {
+			t.Fatal(err)
+		}
+		if d := h2.Store().Chat(wire.ChatURI(id)).Draft; d == nil || d.Model == nil || d.Model.Id != "seeded-model" {
+			t.Fatalf("draft = %+v", d)
+		}
+	})
+
+	twin.Run(t, "session-config", "publishes the model and config actually in effect as the chat draft", func(t *testing.T) {
+		// There is no protocol field for "the default model"; a client initialises its input from
+		// draft, so this is how a host answers. The backend must also correct a stale config for
+		// the same model id.
+		d := draft()
+		if d.Model.Id != "default-model" || string(d.Model.Config[pi.ThinkingConfigKey]) != `"medium"` {
+			t.Fatalf("draft model = %+v", d.Model)
+		}
+	})
+
+	twin.Run(t, "session-config", "applies the model a client picked, before the prompt runs", func(t *testing.T) {
+		promptsBefore, selectionsBefore := len(backend.promptList()), backend.selectionCount()
+		message := userMessage("hi")
+		message["model"] = obj{"id": "picked-model", "config": obj{pi.ThinkingConfigKey: "high"}}
+		client.Dispatch(chat, obj{"type": "chat/turnStarted", "turnId": "t-model", "startedAt": "2025-01-01T00:00:00.000Z", "message": message})
+		testkit.Eventually(t, "the prompt to reach the backend", func() bool { return len(backend.promptList()) == promptsBefore+1 })
+		if backend.selectionCount() != selectionsBefore+1 {
+			t.Fatalf("selections = %d, want %d", backend.selectionCount(), selectionsBefore+1)
+		}
+		backend.recordingBackend.mu.Lock()
+		last := backend.selections[len(backend.selections)-1]
+		backend.recordingBackend.mu.Unlock()
+		sameJSON(t, last, obj{"id": "picked-model", "config": obj{pi.ThinkingConfigKey: "high"}}, "selection")
+		testkit.Eventually(t, "the turn to settle", func() bool { return h.Store().Chat(chat).ActiveTurn == nil })
+	})
+
+	twin.Run(t, "session-config", "runs on the current model when the message carries no selection", func(t *testing.T) {
+		selectionsBefore, promptsBefore := backend.selectionCount(), len(backend.promptList())
+		client.Dispatch(chat, obj{"type": "chat/turnStarted", "turnId": "t-plain", "startedAt": "2025-01-01T00:00:00.000Z", "message": userMessage("again")})
+		testkit.Eventually(t, "the prompt to reach the backend", func() bool { return len(backend.promptList()) == promptsBefore+1 })
+		if backend.selectionCount() != selectionsBefore {
+			t.Fatal("no selection means no switch")
+		}
+	})
+}

package/extensions/ahp/internal/pi/deletesession.go

@@ -0,0 +1,69 @@
+package pi
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+)
+
+// DeleteResult is the outcome of deleting a session file.
+type DeleteResult struct {
+	OK bool
+	// Method is "trash", "unlink" or "missing".
+	Method string
+	Error  string
+}
+
+func isMissing(path string) bool {
+	_, err := os.Lstat(path)
+	return errors.Is(err, os.ErrNotExist) || errors.Is(err, syscall.ENOTDIR)
+}
+
+// DeleteSessionFile removes a session file the way Pi's own /resume delete does: through the
+// system trash when there is one, else by unlinking. Success is judged by the file being gone,
+// not by any exit status: a wrapper or broken installation can exit successfully without moving
+// the file, and a trash that moved it may still exit non-zero (port of src/pi/delete-session.ts).
+func DeleteSessionFile(path string) DeleteResult {
+	if isMissing(path) {
+		return DeleteResult{OK: true, Method: "missing"}
+	}
+	// "--" guards against a path that looks like a flag.
+	args := []string{path}
+	if strings.HasPrefix(path, "-") {
+		args = []string{"--", path}
+	}
+	if bin, err := exec.LookPath("trash"); err == nil {
+		_ = exec.Command(bin, args...).Run()
+	}
+	if isMissing(path) {
+		return DeleteResult{OK: true, Method: "trash"}
+	}
+	if err := unlink(path); err != nil {
+		// Another process deleting the same session is still the desired outcome.
+		if isMissing(path) {
+			return DeleteResult{OK: true, Method: "missing"}
+		}
+		return DeleteResult{OK: false, Method: "unlink", Error: err.Error()}
+	}
+	return DeleteResult{OK: true, Method: "unlink"}
+}
+
+// unlink removes a file but never a directory (os.Remove would also rmdir an empty one).
+func unlink(path string) error {
+	info, err := os.Lstat(path)
+	if err != nil {
+		return err
+	}
+	if info.IsDir() {
+		return &os.PathError{Op: "unlink", Path: path, Err: errors.New("is a directory")}
+	}
+	return os.Remove(path)
+}
+
+// FileDeleter adapts DeleteSessionFile to the registry's deletion boundary.
+func FileDeleter(path string) (SessionFileDeletionResult, error) {
+	r := DeleteSessionFile(path)
+	return SessionFileDeletionResult{OK: r.OK, Error: r.Error}, nil
+}