@pi-in-go/pigpen-ahp 0.1.0

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

@@ -0,0 +1,128 @@
+package pi_test
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pi"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/testkit"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+)
+
+// Twins of upstream test/models.test.ts: mapping Pi's model catalogue onto protocol agent/model
+// descriptions.
+
+func testModel(mutate ...func(*pi.Model)) pi.Model {
+	m := pi.Model{
+		ID: "claude-sonnet-4", Name: "Claude Sonnet 4", API: "anthropic-messages", Provider: "anthropic",
+		BaseURL: "https://api.anthropic.com", Reasoning: true, Input: []string{"text", "image"},
+		Cost:          json.RawMessage(`{"input":3,"output":15,"cacheRead":0.3,"cacheWrite":3.75}`),
+		ContextWindow: 200_000, MaxTokens: 16_384,
+	}
+	for _, f := range mutate {
+		f(&m)
+	}
+	return m
+}
+
+func TestModelMapping(t *testing.T) {
+	twin.Run(t, "models", "offers the standard thinking levels when no extended levels are declared", func(t *testing.T) {
+		if got := pi.SupportedThinkingLevels(testModel()); !reflect.DeepEqual(got, []string{"off", "minimal", "low", "medium", "high"}) {
+			t.Fatalf("levels = %v", got)
+		}
+	})
+
+	twin.Run(t, "models", "offers only `off` for a model without reasoning", func(t *testing.T) {
+		got := pi.SupportedThinkingLevels(testModel(func(m *pi.Model) { m.Reasoning = false }))
+		if !reflect.DeepEqual(got, []string{"off"}) {
+			t.Fatalf("levels = %v", got)
+		}
+	})
+
+	twin.Run(t, "models", "drops unsupported levels and opts into extended levels exactly as pi does", func(t *testing.T) {
+		m := testModel(func(m *pi.Model) {
+			m.ThinkingLevelMap = map[string]json.RawMessage{"off": json.RawMessage("null"), "minimal": json.RawMessage("null"), "xhigh": json.RawMessage(`"xhigh"`), "max": json.RawMessage("null")}
+		})
+		if got := pi.SupportedThinkingLevels(m); !reflect.DeepEqual(got, []string{"low", "medium", "high", "xhigh"}) {
+			t.Fatalf("levels = %v", got)
+		}
+	})
+
+	twin.Run(t, "models", "uses pi's provider-qualified model ids on the wire", func(t *testing.T) {
+		if got := pi.ModelSelectionID("anthropic", "claude-sonnet-4"); got != "anthropic/claude-sonnet-4" {
+			t.Fatalf("id = %s", got)
+		}
+		m := testModel(func(m *pi.Model) { m.Provider, m.ID = "openrouter", "anthropic/claude-sonnet-4" })
+		if got := m.SelectionID(); got != "openrouter/anthropic/claude-sonnet-4" {
+			t.Fatalf("id = %s", got)
+		}
+	})
+
+	twin.Run(t, "models", "resolves qualified ids without confusing providers", func(t *testing.T) {
+		direct := testModel(func(m *pi.Model) { m.Provider, m.ID, m.Name = "openai", "gpt-6-astra", "GPT-6 Astra (API)" })
+		codex := testModel(func(m *pi.Model) { m.Provider, m.ID, m.Name = "openai-codex", "gpt-6-astra", "GPT-6 Astra (Codex)" })
+		models := []pi.Model{direct, codex}
+		if got, ok := pi.FindModelBySelectionID(models, codex.SelectionID(), nil); !ok || got.Name != codex.Name {
+			t.Fatalf("qualified lookup = %+v %v", got, ok)
+		}
+		if _, ok := pi.FindModelBySelectionID(models, "gpt-6-astra", nil); ok {
+			t.Fatal("an ambiguous bare id must not resolve")
+		}
+		if got, ok := pi.FindModelBySelectionID(models, "gpt-6-astra", &codex); !ok || got.Name != codex.Name {
+			t.Fatalf("bare id with the current model = %+v %v", got, ok)
+		}
+	})
+
+	twin.Run(t, "models", "accepts an unambiguous legacy bare model id", func(t *testing.T) {
+		only := testModel()
+		other := testModel(func(m *pi.Model) { m.ID = "other-model" })
+		if got, ok := pi.FindModelBySelectionID([]pi.Model{only, other}, only.ID, nil); !ok || got.ID != only.ID {
+			t.Fatalf("got %+v %v", got, ok)
+		}
+	})
+
+	twin.Run(t, "models", "exposes thinking level as a model configSchema", func(t *testing.T) {
+		info := pi.ToSessionModelInfo(testModel())
+		if info.ConfigSchema == nil {
+			t.Fatal("no configSchema")
+		}
+		property, ok := info.ConfigSchema.Properties[pi.ThinkingConfigKey]
+		if !ok || property.Type != "string" || string(*property.Default) != `"medium"` {
+			t.Fatalf("property = %+v", property)
+		}
+		sameJSON(t, property.Enum, []string{"off", "minimal", "low", "medium", "high"}, "enum")
+		if info.Id != "anthropic/claude-sonnet-4" || info.Provider != pi.Provider || info.MaxContextWindow == nil || *info.MaxContextWindow != 200_000 {
+			t.Fatalf("info = %+v", info)
+		}
+	})
+
+	twin.Run(t, "models", "maps pi input modalities onto the vision capability", func(t *testing.T) {
+		if v := pi.ToSessionModelInfo(testModel()).SupportsVision; v == nil || !*v {
+			t.Fatal("an image-capable model must support vision")
+		}
+		if v := pi.ToSessionModelInfo(testModel(func(m *pi.Model) { m.Input = []string{"text"} })).SupportsVision; v == nil || *v {
+			t.Fatal("a text-only model must not support vision")
+		}
+	})
+
+	twin.Run(t, "models", "omits the configSchema when there is nothing to choose", func(t *testing.T) {
+		// A single-option picker is worse than no picker.
+		if pi.ToSessionModelInfo(testModel(func(m *pi.Model) { m.Reasoning = false })).ConfigSchema != nil {
+			t.Fatal("configSchema must be omitted")
+		}
+	})
+
+	twin.Run(t, "models", "produces a schema-conforming AgentInfo", func(t *testing.T) {
+		agent := pi.BuildAgentInfo([]pi.Model{testModel(), testModel(func(m *pi.Model) { m.ID, m.Name, m.Reasoning = "gpt-5", "GPT-5", false })})
+		if agent.Provider != pi.Provider || len(agent.Models) != 2 {
+			t.Fatalf("agent = %+v", agent)
+		}
+		// No capabilities declared: one chat, one working directory. Their absence is what tells a
+		// client not to attempt those calls.
+		if agent.Capabilities != nil || len(agent.ProtectedResources) != 0 || agent.Customizations != nil {
+			t.Fatalf("agent declares more than it supports: %+v", agent)
+		}
+		testkit.AssertValid(t, "state", "AgentInfo", agent)
+	})
+}

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

@@ -0,0 +1,95 @@
+package pi
+
+import (
+	"fmt"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/host"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+const defaultPageSize = 20
+
+// OlderTurnsPage is a page of history older than what the client already has.
+type OlderTurnsPage struct {
+	Turns      []ahptypes.Turn
+	NextCursor string
+}
+
+func fullBranchTurns(store SessionStore, prefix string) []ahptypes.Turn {
+	return RebuildHistory(store.Branch(""), RebuildOptions{TurnIDPrefix: prefix}).Turns
+}
+
+func indexOfTurn(turns []ahptypes.Turn, id string) int {
+	for i, t := range turns {
+		if t.Id == id {
+			return i
+		}
+	}
+	return -1
+}
+
+// InitialTurnsCursor is the cursor a client needs to fetch what precedes the visible window, ""
+// when the window already starts at the beginning. The cursor is the id of the oldest visible turn.
+func InitialTurnsCursor(store SessionStore, prefix string, visible []ahptypes.Turn) string {
+	if len(visible) == 0 {
+		return ""
+	}
+	if indexOfTurn(fullBranchTurns(store, prefix), visible[0].Id) > 0 {
+		return visible[0].Id
+	}
+	return ""
+}
+
+// LoadOlderTurns returns the page of turns ending just before cursor.
+func LoadOlderTurns(store SessionStore, prefix, cursor string, limit int) OlderTurnsPage {
+	if cursor == "" {
+		return OlderTurnsPage{Turns: []ahptypes.Turn{}}
+	}
+	if limit <= 0 {
+		limit = defaultPageSize
+	}
+	full := fullBranchTurns(store, prefix)
+	boundary := indexOfTurn(full, cursor)
+	if boundary <= 0 {
+		return OlderTurnsPage{Turns: []ahptypes.Turn{}}
+	}
+	start := boundary - limit
+	if start < 0 {
+		start = 0
+	}
+	page := OlderTurnsPage{Turns: append([]ahptypes.Turn{}, full[start:boundary]...)}
+	// More remains only if this page did not reach the beginning.
+	if start > 0 && len(page.Turns) > 0 {
+		page.NextCursor = page.Turns[0].Id
+	}
+	return page
+}
+
+// DispatchOlderTurns serves fetchTurns: the page is dispatched to the chat before it returns.
+func DispatchOlderTurns(h *host.Host, channel string, source HistorySource, cursor *string) error {
+	state := h.Store().Chat(channel)
+	if cursor != nil {
+		var next string
+		if state != nil && state.TurnsNextCursor != nil {
+			next = *state.TurnsNextCursor
+		}
+		if state == nil || state.TurnsNextCursor == nil || *cursor != next {
+			return wire.InvalidParams(fmt.Sprintf("Unrecognised fetchTurns cursor for %s", channel))
+		}
+	}
+	c := ""
+	if cursor != nil {
+		c = *cursor
+	}
+	page := LoadOlderTurns(source.Store(), source.ID(), c, 0)
+	// Dispatched even when empty: it is what clears a cursor that has no more history behind it, so
+	// the client stops asking.
+	action := &ahptypes.ChatTurnsLoadedAction{Type: ahptypes.ActionTypeChatTurnsLoaded, Turns: page.Turns}
+	if page.NextCursor != "" {
+		action.TurnsNextCursor = &page.NextCursor
+	}
+	h.DispatchServerAction(channel, ahptypes.StateAction{Value: action})
+	return nil
+}

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

@@ -0,0 +1,323 @@
+package pi_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/host"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/mapper"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pi"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pisession"
+	"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/fetch-turns.test.ts and test/truncate.test.ts.
+
+// sessionFileFixture is a host serving one pre-written session file.
+type sessionFileFixture struct {
+	t         *testing.T
+	host      *host.Host
+	client    *testkit.Client
+	sessionID string
+	root      string
+}
+
+func (f *sessionFileFixture) chat() string    { return wire.ChatURI(f.sessionID) }
+func (f *sessionFileFixture) session() string { return wire.SessionURI(f.sessionID) }
+
+func startSessionFile(t *testing.T, write func(root, id, cwd string), backend pi.Backend) *sessionFileFixture {
+	t.Helper()
+	f := &sessionFileFixture{t: t, root: t.TempDir(), sessionID: newID()}
+	workspace := t.TempDir()
+	write(f.root, f.sessionID, workspace)
+	opts := pi.ServicesOptions{
+		SessionRoot: f.root, DefaultWorkingDirectory: workspace,
+		CreateSessionManager: pi.PersistentStorage(filepath.Join(f.root, "created")),
+	}
+	f.host = testkit.NewHost(host.Options{})
+	opts.Host = f.host
+	if backend != nil {
+		opts.CreateBackend = func(*pi.LiveSession) (pi.Backend, error) { return backend, nil }
+	}
+	services := pi.NewServices(opts)
+	f.host.Serve(services.Capabilities())
+	f.client = testkit.Connect(t, f.host)
+	t.Cleanup(f.client.Close)
+	f.client.Initialize("paging-client", nil)
+	return f
+}
+
+// jsonl builds a session file body: header + entries linked by id/parentId.
+type jsonl struct {
+	lines  []string
+	parent any
+	n      int
+}
+
+func newJSONL(id, cwd string) *jsonl {
+	raw, _ := json.Marshal(obj{"type": "session", "id": id, "parentId": nil, "timestamp": "2026-01-01T00:00:00.000Z", "version": 3, "cwd": cwd})
+	return &jsonl{lines: []string{string(raw)}}
+}
+
+func (j *jsonl) push(entry obj) string {
+	j.n++
+	id := "n" + strconv.Itoa(j.n)
+	entry["id"], entry["parentId"], entry["timestamp"] = id, j.parent, "2026-01-01T00:00:00.000Z"
+	raw, _ := json.Marshal(entry)
+	j.lines = append(j.lines, string(raw))
+	j.parent = id
+	return id
+}
+
+func (j *jsonl) message(role string, content any) string {
+	return j.push(obj{"type": "message", "message": obj{"role": role, "content": content, "timestamp": 0}})
+}
+
+func (j *jsonl) write(t testing.TB, root, id, cwd string) {
+	dir := fixtureSessionDirectory(t, root, cwd)
+	if err := os.WriteFile(filepath.Join(dir, "2026-01-01T00-00-00-000Z_"+id+".jsonl"), []byte(strings.Join(j.lines, "\n")+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// writeCompactedSession writes a session with `before` exchanges, then a compaction, then `after`.
+// The compaction is what makes the earlier turns invisible to the default window, which is exactly
+// the case paging exists for.
+func writeCompactedSession(before, after int) func(root, id, cwd string) {
+	return func(root, id, cwd string) {
+		j := newJSONL(id, cwd)
+		exchange := func(n int) {
+			j.message("user", fmt.Sprintf("question %d", n))
+			j.message("assistant", []any{obj{"type": "text", "text": fmt.Sprintf("answer %d", n)}})
+		}
+		for i := 0; i < before; i++ {
+			exchange(i)
+		}
+		// The compaction keeps nothing before itself: firstKeptEntryId points at the entry that
+		// follows it, so the window starts here.
+		j.push(obj{"type": "compaction", "summary": "earlier work", "firstKeptEntryId": "none", "tokensBefore": 1000})
+		for i := 0; i < after; i++ {
+			exchange(before + i)
+		}
+		j.write(t0{}, root, id, cwd)
+	}
+}
+
+// t0 lets the writers above (called without a *testing.T) fail loudly.
+type t0 struct{ testing.TB }
+
+func (t0) Helper()                           {}
+func (t0) Fatal(args ...any)                 { panic(fmt.Sprint(args...)) }
+func (t0) Fatalf(format string, args ...any) { panic(fmt.Sprintf(format, args...)) }
+
+func TestFetchTurns(t *testing.T) {
+	// 25 pre-compaction exchanges, so a 20-turn page leaves a second one.
+	f := startSessionFile(t, writeCompactedSession(25, 2), nil)
+	f.client.Subscribe(f.chat())
+	state := func() *ahptypes.ChatState { return f.host.Store().Chat(f.chat()) }
+
+	twin.Run(t, "fetch-turns", "pages backward while preserving a complete oldest-first transcript", func(t *testing.T) {
+		initial := state()
+		// Its presence is the protocol's signal that turns is a tail window.
+		if initial.TurnsNextCursor == nil {
+			t.Fatal("a compacted session must offer more history")
+		}
+		testkit.AssertValid(t, "state", "ChatState", initial)
+		newest := initial.Turns[len(initial.Turns)-1].Id
+		initialCount := len(initial.Turns)
+
+		f.client.Must("fetchTurns", obj{"channel": f.chat(), "cursor": *initial.TurnsNextCursor})
+		current := state()
+		if len(current.Turns) <= initialCount {
+			t.Fatalf("no older turns arrived: %d", len(current.Turns))
+		}
+		if got := current.Turns[len(current.Turns)-1].Id; got != newest {
+			t.Fatalf("paging must preserve the visible tail: %s vs %s", got, newest)
+		}
+		if !regexp.MustCompile(`question \d+`).MatchString(current.Turns[0].Message.Text) {
+			t.Fatalf("oldest turn = %q", current.Turns[0].Message.Text)
+		}
+		for current.TurnsNextCursor != nil {
+			f.client.Must("fetchTurns", obj{"channel": f.chat(), "cursor": *current.TurnsNextCursor})
+			current = state()
+		}
+		var numbered []int
+		re := regexp.MustCompile(`question (\d+)`)
+		for _, turn := range current.Turns {
+			if m := re.FindStringSubmatch(turn.Message.Text); m != nil {
+				n, _ := strconv.Atoi(m[1])
+				numbered = append(numbered, n)
+			}
+		}
+		if !sort.IntsAreSorted(numbered) || len(numbered) != 27 {
+			t.Fatalf("questions = %v", numbered)
+		}
+		// Without this the client would keep asking for pages that do not exist.
+		if current.TurnsNextCursor != nil {
+			t.Fatal("the cursor must clear once history is exhausted")
+		}
+	})
+
+	twin.Run(t, "fetch-turns", "rejects a session channel for this chat-scoped command", func(t *testing.T) {
+		f.client.ExpectError("fetchTurns", obj{"channel": f.session()}, wire.CodeInvalidParams)
+	})
+
+	twin.Run(t, "fetch-turns", "rejects a cursor it did not issue", func(t *testing.T) {
+		f.client.ExpectError("fetchTurns", obj{"channel": f.chat(), "cursor": "made-up"}, -32602)
+	})
+
+	twin.Run(t, "fetch-turns", "offers no cursor for a session that was never compacted", func(t *testing.T) {
+		fresh := startSessionFile(t, writeCompactedSession(0, 3), nil)
+		chat := snapshotState[ahptypes.ChatState](t, fresh.client, fresh.chat())
+		if chat.TurnsNextCursor != nil {
+			t.Fatalf("turnsNextCursor = %v", *chat.TurnsNextCursor)
+		}
+	})
+}
+
+// truncatingBackend records the entries it was asked to move back to.
+type truncatingBackend struct {
+	mu        sync.Mutex
+	truncated []string
+	accept    bool
+}
+
+func (b *truncatingBackend) Subscribe(func(mapper.Event)) func()                  { return func() {} }
+func (b *truncatingBackend) Prompt(context.Context, string, []mapper.Image) error { return nil }
+func (b *truncatingBackend) Steer(context.Context, string, []mapper.Image) error  { return nil }
+func (b *truncatingBackend) Abort(context.Context) error                          { return nil }
+func (b *truncatingBackend) Truncate(_ context.Context, entryID string) (bool, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.truncated = append(b.truncated, entryID)
+	return b.accept, nil
+}
+func (b *truncatingBackend) list() []string {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return append([]string(nil), b.truncated...)
+}
+
+// writeTwoTurns is upstream truncate.test.ts's writeSession: two complete turns.
+func writeTwoTurns(root, id, cwd string) {
+	j := newJSONL(id, cwd)
+	j.message("user", "first question")
+	j.message("assistant", []any{obj{"type": "text", "text": "first answer"}})
+	j.message("user", "second question")
+	j.message("assistant", []any{obj{"type": "text", "text": "second answer"}})
+	j.write(t0{}, root, id, cwd)
+}
+
+func TestTruncationAnchors(t *testing.T) {
+	entry := func(id, role, text string) pisession.Entry {
+		return pisession.Entry{"type": "message", "id": id, "parentId": nil, "timestamp": "2026-01-01T00:00:00.000Z", "message": obj{"role": role, "content": text}}
+	}
+	twin.Run(t, "truncate", "anchors a turn on its last entry, not its first", func(t *testing.T) {
+		// navigateTree is inclusive for a non-user entry and exclusive for a user one, so pointing
+		// at the turn's *last* entry is what expresses "keep turns up to and including this one".
+		history := pi.RebuildHistory([]pisession.Entry{entry("u1", "user", "q1"), entry("a1", "assistant", "a1"), entry("u2", "user", "q2"), entry("a2", "assistant", "a2")}, pi.RebuildOptions{TurnIDPrefix: "s"})
+		if len(history.Turns) != 2 {
+			t.Fatalf("%d turns", len(history.Turns))
+		}
+		if history.Anchors[history.Turns[0].Id] != "a1" || history.Anchors[history.Turns[1].Id] != "a2" {
+			t.Fatalf("anchors = %v", history.Anchors)
+		}
+	})
+
+	twin.Run(t, "truncate", "anchors 'clear everything' on the first user entry", func(t *testing.T) {
+		// Navigating to a user entry lands the leaf on its parent, and the first one's parent is
+		// null, which is how Pi expresses an empty branch.
+		u1 := entry("u1", "user", "q")
+		a1 := entry("a1", "assistant", "a")
+		a1["parentId"] = "u1"
+		history := pi.RebuildHistory([]pisession.Entry{u1, a1}, pi.RebuildOptions{TurnIDPrefix: "s"})
+		if history.Anchors[pi.ClearAllAnchor] != "u1" {
+			t.Fatalf("anchors = %v", history.Anchors)
+		}
+	})
+}
+
+func TestChatTruncated(t *testing.T) {
+	twin.Run(t, "truncate", "moves pi's leaf to the named turn, not just the client's view", func(t *testing.T) {
+		backend := &truncatingBackend{accept: true}
+		f := startSessionFile(t, writeTwoTurns, backend)
+		chat := snapshotState[ahptypes.ChatState](t, f.client, f.chat())
+		if len(chat.Turns) != 2 {
+			t.Fatalf("%d turns", len(chat.Turns))
+		}
+		f.client.Dispatch(f.chat(), obj{"type": "chat/truncated", "turnId": chat.Turns[0].Id})
+		testkit.Eventually(t, "pi's history to receive the truncation", func() bool { return len(backend.list()) == 1 })
+		// Both halves have to move: the reducer drops the later turn, and Pi is told to branch from
+		// the kept one.
+		if got := len(f.host.Store().Chat(f.chat()).Turns); got != 1 {
+			t.Fatalf("%d turns remain", got)
+		}
+		// The entry Pi is told to move to is the kept turn's last entry (the first answer).
+		file, _ := pi.NewCatalogue(f.root).FindSessionFile(f.sessionID)
+		m, _ := pisession.Open(file)
+		var assistantIDs []string
+		for _, e := range m.Entries() {
+			if e.Role() == "assistant" {
+				assistantIDs = append(assistantIDs, e.ID())
+			}
+		}
+		if !reflect.DeepEqual(backend.list(), assistantIDs[:1]) {
+			t.Fatalf("truncated to %v, want %v", backend.list(), assistantIDs[:1])
+		}
+	})
+
+	twin.Run(t, "truncate", "maps 'clear everything' onto the first entry", func(t *testing.T) {
+		backend := &truncatingBackend{accept: true}
+		f := startSessionFile(t, writeTwoTurns, backend)
+		f.client.Subscribe(f.chat())
+		f.client.Dispatch(f.chat(), obj{"type": "chat/truncated"})
+		testkit.Eventually(t, "pi's history to receive the clear-all truncation", func() bool { return len(backend.list()) == 1 })
+		if got := len(f.host.Store().Chat(f.chat()).Turns); got != 0 {
+			t.Fatalf("%d turns remain", got)
+		}
+		file, _ := pi.NewCatalogue(f.root).FindSessionFile(f.sessionID)
+		m, _ := pisession.Open(file)
+		if first := m.Entries()[0].ID(); !reflect.DeepEqual(backend.list(), []string{first}) {
+			t.Fatalf("truncated to %v, want the first entry %s", backend.list(), first)
+		}
+	})
+
+	twin.Run(t, "truncate", "refuses a turn it cannot anchor, instead of diverging", func(t *testing.T) {
+		backend := &truncatingBackend{accept: true}
+		f := startSessionFile(t, writeTwoTurns, backend)
+		before := len(snapshotState[ahptypes.ChatState](t, f.client, f.chat()).Turns)
+		mark := len(f.client.Notifications())
+		f.client.Dispatch(f.chat(), obj{"type": "chat/truncated", "turnId": "no-such-turn"})
+		// Refused before the reducer runs: accepting would truncate the client's view while Pi
+		// kept everything.
+		n, ok := f.client.Await(func(n testkit.Notification) bool { _, isAction := n.Envelope(); return isAction }, testkit.Timeout)
+		_ = mark
+		if !ok {
+			t.Fatal("no action envelope")
+		}
+		env, _ := n.Envelope()
+		if env.RejectionReason == nil || !strings.Contains(*env.RejectionReason, "Cannot truncate") {
+			t.Fatalf("rejectionReason = %v", env.RejectionReason)
+		}
+		if got := len(f.host.Store().Chat(f.chat()).Turns); got != before {
+			t.Fatalf("%d turns, want %d", got, before)
+		}
+		if got := backend.list(); len(got) != 0 {
+			t.Fatalf("truncated = %v", got)
+		}
+	})
+}