@pi-in-go/pigpen-ahp 0.1.0

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

@@ -0,0 +1,269 @@
+package pi
+
+import (
+	"strings"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/mapper"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pisession"
+)
+
+// Rebuilds chat history from a pi session file (port of src/pi/history.ts).
+//
+// A session from the catalogue exists only on disk, so subscribing to it has to reconstruct its
+// state, or the client opens an empty conversation. The window matches what pi itself renders:
+// the most recent compaction onward (ContextEntries), which is the transcript pi's own TUI shows
+// on resume; reconstructing more would show the user history their agent has already forgotten.
+//
+// This is a second mapper, distinct from the streaming one: it works from finished messages
+// rather than deltas, so there is no partial state and every tool call already has its result.
+
+// ClearAllAnchor is the key under which the whole-conversation anchor is stored.
+const ClearAllAnchor = ""
+
+// RebuiltHistory is the result of a rebuild.
+type RebuiltHistory struct {
+	Turns []ahptypes.Turn
+	// Anchors maps a turn id to the session entry that turn ends on: what truncation needs.
+	// chat/truncated keeps turns up to and including the named one, and pointing the agent at a
+	// turn's last entry expresses exactly that. The first user entry is recorded under
+	// ClearAllAnchor: navigating to it lands the leaf on its parent (null), which is how "clear
+	// everything" is expressed.
+	Anchors map[string]string
+}
+
+// RebuildOptions configure a rebuild.
+type RebuildOptions struct {
+	// TurnIDPrefix prefixes generated turn ids; it only needs to be stable within a chat.
+	TurnIDPrefix string
+}
+
+func blocksOf(message map[string]any) []map[string]any {
+	if s, ok := message["content"].(string); ok {
+		return []map[string]any{{"type": "text", "text": s}}
+	}
+	var out []map[string]any
+	if arr, ok := message["content"].([]any); ok {
+		for _, b := range arr {
+			if m, ok := b.(map[string]any); ok {
+				out = append(out, m)
+			}
+		}
+	}
+	return out
+}
+
+func plainText(message map[string]any) string {
+	var sb strings.Builder
+	for _, b := range blocksOf(message) {
+		if b["type"] == "text" {
+			if s, ok := b["text"].(string); ok {
+				sb.WriteString(s)
+			}
+		}
+	}
+	return sb.String()
+}
+
+func numberPtr(v any) *int64 {
+	switch n := v.(type) {
+	case float64:
+		i := int64(n)
+		return &i
+	}
+	return nil
+}
+
+func storedUsage(message map[string]any) *ahptypes.UsageInfo {
+	usage, ok := message["usage"].(map[string]any)
+	if !ok {
+		return nil
+	}
+	info := &ahptypes.UsageInfo{
+		InputTokens: numberPtr(usage["input"]), OutputTokens: numberPtr(usage["output"]), CacheReadTokens: numberPtr(usage["cacheRead"]),
+	}
+	if model, _ := message["model"].(string); model != "" {
+		info.Model = &model
+	}
+	return info
+}
+
+func textResult(text string) []ahptypes.ToolResultContent {
+	return []ahptypes.ToolResultContent{{Value: &ahptypes.ToolResultTextContent{Type: ahptypes.ToolResultContentTypeText, Text: text}}}
+}
+
+type pendingTurn struct {
+	id, startedAt string
+	message       ahptypes.Message
+	parts         []ahptypes.ResponsePart
+	usage         *ahptypes.UsageInfo
+}
+
+func stringOr(v any, def string) string {
+	if s, ok := v.(string); ok && s != "" {
+		return s
+	}
+	return def
+}
+
+// RebuildHistory converts session entries into completed turns.
+//
+// Turn boundaries come from user messages: each one opens a turn that absorbs every assistant
+// message and tool result until the next. That mirrors the live mapper, where a turn spans
+// everything from one prompt to agent_settled.
+func RebuildHistory(entries []pisession.Entry, opts RebuildOptions) RebuiltHistory {
+	prefix := opts.TurnIDPrefix
+	if prefix == "" {
+		prefix = "turn"
+	}
+	turns := []ahptypes.Turn{}
+	anchors := map[string]string{}
+	var lastEntryID string
+	var current *pendingTurn
+	toolCallParts := map[string]int{}
+
+	closeTurn := func() {
+		if current == nil {
+			return
+		}
+		if lastEntryID != "" {
+			anchors[current.id] = lastEntryID
+		}
+		started := current.startedAt
+		turns = append(turns, ahptypes.Turn{
+			Id: current.id, StartedAt: &started, Message: current.message,
+			ResponseParts: current.parts, Usage: current.usage, State: ahptypes.TurnStateComplete,
+		})
+		current = nil
+		toolCallParts = map[string]int{}
+	}
+	openTurn := func(id, startedAt string, message ahptypes.Message) {
+		closeTurn()
+		current = &pendingTurn{id: id, startedAt: startedAt, message: message, parts: []ahptypes.ResponsePart{}}
+	}
+
+	for _, entry := range entries {
+		if entry.Role() == "user" {
+			if _, set := anchors[ClearAllAnchor]; !set {
+				anchors[ClearAllAnchor] = entry.ID()
+			}
+		}
+
+		if entry.Type() == "compaction" {
+			// The summary replaces everything before it. Surfacing it as a turn of its own tells
+			// the user why the history starts where it does.
+			closeTurn()
+			started := entry.Timestamp()
+			summary, _ := entry["summary"].(string)
+			turns = append(turns, ahptypes.Turn{
+				Id: prefix + "-compaction-" + entry.ID(), StartedAt: &started,
+				Message: ahptypes.Message{Text: "", Origin: ahptypes.MessageOrigin{Kind: ahptypes.MessageKindUser}},
+				ResponseParts: []ahptypes.ResponsePart{{Value: &ahptypes.SystemNotificationResponsePart{
+					Kind:    ahptypes.ResponsePartKindSystemNotification,
+					Content: ahptypes.NewStringOrMarkdownPlain("Conversation compacted.\n\n" + summary),
+				}}},
+				State: ahptypes.TurnStateComplete,
+			})
+			continue
+		}
+		if entry.Type() != "message" {
+			continue // model / thinking-level changes and labels carry no transcript
+		}
+
+		message := entry.Message()
+		switch message["role"] {
+		case "user":
+			openTurn(prefix+"-"+entry.ID(), entry.Timestamp(), mapper.UserMessageFromPiContent(message["content"]))
+		case "assistant":
+			if current == nil {
+				// An assistant message with no preceding user message (a truncated file, or history
+				// that starts mid-turn): give it a turn so the content is not dropped.
+				openTurn(prefix+"-"+entry.ID(), entry.Timestamp(), mapper.UserMessageFromPiContent(""))
+			}
+			for index, block := range blocksOf(message) {
+				partID := current.id + ":" + entry.ID() + ":" + itoa(index)
+				switch {
+				case block["type"] == "text" && stringOr(block["text"], "") != "":
+					current.parts = append(current.parts, ahptypes.ResponsePart{Value: &ahptypes.MarkdownResponsePart{
+						Kind: ahptypes.ResponsePartKindMarkdown, Id: partID, Content: block["text"].(string)}})
+				case block["type"] == "thinking" && stringOr(block["thinking"], "") != "":
+					current.parts = append(current.parts, ahptypes.ResponsePart{Value: &ahptypes.ReasoningResponsePart{
+						Kind: ahptypes.ResponsePartKindReasoning, Id: partID, Content: block["thinking"].(string)}})
+				case block["type"] == "toolCall" && stringOr(block["id"], "") != "":
+					id := block["id"].(string)
+					name := stringOr(block["name"], "tool")
+					toolCallParts[id] = len(current.parts)
+					running := &ahptypes.ToolCallRunningState{
+						Status: ahptypes.ToolCallStatusRunning, ToolCallId: id, ToolName: name, DisplayName: name,
+						InvocationMessage: ahptypes.NewStringOrMarkdownPlain(name), Confirmed: ahptypes.ToolCallConfirmationReasonSetting,
+					}
+					if args, present := block["arguments"]; present {
+						if s, err := mapper.StringifyJSON(args, false); err == nil {
+							running.ToolInput = &ahptypes.ToolInput{Inline: &s}
+						}
+					}
+					current.parts = append(current.parts, ahptypes.ResponsePart{Value: &ahptypes.ToolCallResponsePart{
+						Kind: ahptypes.ResponsePartKindToolCall, ToolCall: ahptypes.ToolCallState{Value: running}}})
+				}
+			}
+			if u := storedUsage(message); u != nil {
+				current.usage = u
+			}
+		case "toolResult":
+			callID, _ := message["toolCallId"].(string)
+			idx, found := toolCallParts[callID]
+			if current == nil || callID == "" || !found {
+				break
+			}
+			part, ok := current.parts[idx].Value.(*ahptypes.ToolCallResponsePart)
+			if !ok {
+				break
+			}
+			running, ok := part.ToolCall.Value.(*ahptypes.ToolCallRunningState)
+			if !ok {
+				break
+			}
+			name := stringOr(message["toolName"], "tool")
+			success := message["isError"] != true
+			past := "Ran " + name
+			if !success {
+				past = name + " failed"
+			}
+			done := &ahptypes.ToolCallCompletedState{
+				Status: ahptypes.ToolCallStatusCompleted, ToolCallId: running.ToolCallId, ToolName: running.ToolName,
+				DisplayName: running.DisplayName, InvocationMessage: running.InvocationMessage, ToolInput: running.ToolInput,
+				Confirmed: running.Confirmed, Success: success, PastTenseMessage: ahptypes.NewStringOrMarkdownPlain(past),
+			}
+			if text := plainText(message); text != "" {
+				done.Content = textResult(text)
+			}
+			current.parts[idx] = ahptypes.ResponsePart{Value: &ahptypes.ToolCallResponsePart{
+				Kind: ahptypes.ResponsePartKindToolCall, ToolCall: ahptypes.ToolCallState{Value: done}}}
+		case "bashExecution":
+			// pi records `!command` runs as their own message role; they are part of the transcript
+			// even though no model produced them.
+			command, _ := message["command"].(string)
+			output, _ := message["output"].(string)
+			if current == nil {
+				openTurn(prefix+"-"+entry.ID(), entry.Timestamp(), mapper.UserMessageFromPiContent("!"+command))
+			}
+			current.parts = append(current.parts, ahptypes.ResponsePart{Value: &ahptypes.SystemNotificationResponsePart{
+				Kind: ahptypes.ResponsePartKindSystemNotification, Content: ahptypes.NewStringOrMarkdownPlain("`" + command + "`\n\n" + output)}})
+		}
+		// Recorded after the entry has been folded in, so a user message that opens a new turn
+		// does not become the previous turn's anchor.
+		lastEntryID = entry.ID()
+	}
+	closeTurn()
+	return RebuiltHistory{Turns: turns, Anchors: anchors}
+}
+
+// RebuildHistoryFromSession rebuilds the turns of a session with the window pi's TUI shows.
+func RebuildHistoryFromSession(store SessionStore, opts RebuildOptions) RebuiltHistory {
+	return RebuildHistory(store.ContextEntries(), opts)
+}
+
+func itoa(i int) string {
+	return mapper.Itoa(i)
+}

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

@@ -0,0 +1,171 @@
+package pi_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"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/testkit"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+// writeSession writes a Pi session file containing one full turn with a tool call, then a second
+// user message (upstream test/support/hydrated-session.ts).
+func writeSession(t testing.TB, root, id, cwd string, includeImage bool) string {
+	t.Helper()
+	dir := fixtureSessionDirectory(t, root, cwd)
+	at := "2026-01-01T00:00:00.000Z"
+	line := func(v map[string]any) string { raw, _ := json.Marshal(v); return string(raw) }
+	lines := []string{line(map[string]any{"type": "session", "id": id, "parentId": nil, "timestamp": at, "version": 3, "cwd": cwd})}
+	var parent any
+	n := 0
+	push := func(entry map[string]any) {
+		n++
+		entryID := fmt.Sprintf("e%d", n)
+		entry["id"], entry["parentId"], entry["timestamp"] = entryID, parent, at
+		lines = append(lines, line(entry))
+		parent = entryID
+	}
+	var userContent any = "Read note.txt"
+	if includeImage {
+		userContent = []any{obj{"type": "text", "text": "Read note.txt"}, obj{"type": "image", "data": onePixelPNG, "mimeType": "image/png"}}
+	}
+	push(obj{"type": "message", "message": obj{"role": "user", "content": userContent, "timestamp": 0}})
+	push(obj{"type": "message", "message": obj{
+		"role": "assistant",
+		"content": []any{obj{"type": "thinking", "thinking": "I should read it."},
+			obj{"type": "toolCall", "id": "tc-1", "name": "read", "arguments": obj{"path": "note.txt"}}},
+		"usage": obj{"input": 10, "output": 5, "cacheRead": 0}, "provider": "fixture", "model": "test-model", "timestamp": 0,
+	}})
+	push(obj{"type": "message", "message": obj{
+		"role": "toolResult", "toolCallId": "tc-1", "toolName": "read", "content": []any{obj{"type": "text", "text": "ALPHA"}}, "timestamp": 0,
+	}})
+	push(obj{"type": "message", "message": obj{
+		"role": "assistant", "content": []any{obj{"type": "text", "text": "It says ALPHA."}}, "provider": "fixture", "model": "test-model", "timestamp": 0,
+	}})
+	push(obj{"type": "message", "message": obj{"role": "user", "content": "Thanks", "timestamp": 0}})
+	path := filepath.Join(dir, "2026-01-01T00-00-00-000Z_"+id+".jsonl")
+	if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+// recordingBackend records what a resumed session actually asks the agent to do.
+type recordingBackend struct {
+	mu        sync.Mutex
+	prompts   []string
+	listeners []func(mapper.Event)
+}
+
+func (b *recordingBackend) Subscribe(l func(mapper.Event)) func() {
+	b.mu.Lock()
+	b.listeners = append(b.listeners, l)
+	b.mu.Unlock()
+	return func() {}
+}
+
+func (b *recordingBackend) Prompt(_ context.Context, text string, _ []mapper.Image) error {
+	b.mu.Lock()
+	b.prompts = append(b.prompts, text)
+	ls := append([]func(mapper.Event){}, b.listeners...)
+	b.mu.Unlock()
+	for _, typ := range []string{"agent_start", "agent_settled"} {
+		for _, l := range ls {
+			l(mapper.Event{"type": typ})
+		}
+	}
+	return nil
+}
+func (b *recordingBackend) Steer(context.Context, string, []mapper.Image) error { return nil }
+func (b *recordingBackend) Abort(context.Context) error                         { return nil }
+
+func (b *recordingBackend) promptList() []string {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return append([]string(nil), b.prompts...)
+}
+
+type hydratedOptions struct {
+	deleteFile   func(path string) (pi.SessionFileDeletionResult, error)
+	includeImage bool
+}
+
+type hydratedFixture struct {
+	t         *testing.T
+	host      *host.Host
+	services  *pi.Services
+	client    *testkit.Client
+	sessionID string
+	root      string
+	workspace string
+	backend   *recordingBackend
+	mu        sync.Mutex
+	deleted   []string
+	extra     int
+}
+
+func (f *hydratedFixture) deletedFiles() []string {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return append([]string(nil), f.deleted...)
+}
+
+func (f *hydratedFixture) session() string { return wire.SessionURI(f.sessionID) }
+func (f *hydratedFixture) chat() string    { return wire.ChatURI(f.sessionID) }
+
+// connectAsVSCode attaches another client that identifies itself as an editor window.
+func (f *hydratedFixture) connectAsVSCode() *testkit.Client {
+	f.t.Helper()
+	f.extra++
+	c := testkit.Connect(f.t, f.host)
+	f.t.Cleanup(c.Close)
+	c.Initialize(fmt.Sprintf("vscode-client-%d", f.extra+1), obj{"clientInfo": obj{"name": "vscode-editor-window", "title": "VS Code"}})
+	return c
+}
+
+func startHydrated(t *testing.T, o hydratedOptions) *hydratedFixture {
+	t.Helper()
+	f := &hydratedFixture{t: t, root: t.TempDir(), backend: &recordingBackend{}}
+	f.workspace = filepath.Join(t.TempDir(), "pi ahp hydrate cwd")
+	if err := os.MkdirAll(f.workspace, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	f.sessionID = newID()
+	writeSession(t, f.root, f.sessionID, f.workspace, o.includeImage)
+	f.host = testkit.NewHost(host.Options{})
+	f.host.Store() // root installed by NewHost
+	f.services = pi.NewServices(pi.ServicesOptions{
+		Host: f.host, SessionRoot: f.root, DefaultWorkingDirectory: f.workspace,
+		CreateBackend:        func(*pi.LiveSession) (pi.Backend, error) { return f.backend, nil },
+		CreateSessionManager: pi.PersistentStorage(filepath.Join(f.root, "created")),
+		DefaultSelection: func() *ahptypes.ModelSelection {
+			return &ahptypes.ModelSelection{Id: "fallback-model", Config: map[string]json.RawMessage{"thinkingLevel": json.RawMessage(`"medium"`)}}
+		},
+		DeleteFile: func(path string) (pi.SessionFileDeletionResult, error) {
+			f.mu.Lock()
+			f.deleted = append(f.deleted, path)
+			f.mu.Unlock()
+			if o.deleteFile != nil {
+				return o.deleteFile(path)
+			}
+			_ = os.Remove(path)
+			return pi.SessionFileDeletionResult{OK: true}, nil
+		},
+	})
+	f.host.Serve(f.services.Capabilities())
+	f.client = testkit.Connect(t, f.host)
+	t.Cleanup(f.client.Close)
+	f.client.Initialize("hydrate-client", nil)
+	return f
+}

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

@@ -0,0 +1,196 @@
+package pi_test
+
+import (
+	"os"
+	"reflect"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"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/hydrated-session-lifecycle.test.ts: operations performed after a durable
+// Pi session has been hydrated.
+
+func (f *hydratedFixture) listItems() []obj {
+	f.t.Helper()
+	var r struct{ Items []obj }
+	f.client.Decode(f.client.Must("listSessions", obj{"channel": wire.RootChannel}), &r)
+	return r.Items
+}
+
+func (f *hydratedFixture) turnStarted(turnID, text string) {
+	f.client.Dispatch(f.chat(), obj{"type": "chat/turnStarted", "turnId": turnID, "startedAt": time.Now().UTC().Format("2006-01-02T15:04:05.000Z"), "message": userMessage(text)})
+}
+
+func TestReadStateAfterHydration(t *testing.T) {
+	f := startHydrated(t, hydratedOptions{})
+	isRead := float64(ahptypes.SessionStatusIsRead)
+
+	twin.Run(t, "hydrated-session-lifecycle", "reports every catalogue entry as read", func(t *testing.T) {
+		items := f.listItems()
+		if int64(items[0]["status"].(float64))&int64(isRead) == 0 {
+			t.Fatalf("status = %v", items[0]["status"])
+		}
+	})
+
+	twin.Run(t, "hydrated-session-lifecycle", "reports a hydrated session as read", func(t *testing.T) {
+		state := snapshotState[ahptypes.SessionState](t, f.client, f.session())
+		if state.Status&ahptypes.SessionStatusIsRead == 0 {
+			t.Fatalf("status = %d", state.Status)
+		}
+		if state.Title != "Read note.txt" {
+			t.Fatalf("title = %q", state.Title)
+		}
+	})
+
+	twin.Run(t, "hydrated-session-lifecycle", "keeps session-owned read state when a starting turn marks the chat unread", func(t *testing.T) {
+		f.client.Subscribe(f.chat())
+		if before := f.host.Store().Chat(f.chat()).Status; before&ahptypes.SessionStatusIsRead == 0 {
+			t.Fatalf("chat status before = %d", before)
+		}
+		f.turnStarted("t-unread", "hi")
+		f.client.Ping()
+		if got := f.host.Store().Chat(f.chat()).Status & ahptypes.SessionStatusIsRead; got != 0 {
+			t.Fatalf("chat still read: %d", got)
+		}
+		if f.host.Store().Session(f.session()).Status&ahptypes.SessionStatusIsRead == 0 {
+			t.Fatal("the session lost its read bit")
+		}
+		for _, item := range f.listItems() {
+			if item["resource"] == f.session() && int64(item["status"].(float64))&int64(isRead) == 0 {
+				t.Fatalf("listed status = %v", item["status"])
+			}
+		}
+	})
+}
+
+func TestDisposingAHydratedSession(t *testing.T) {
+	twin.Run(t, "hydrated-session-lifecycle", "removes it from the catalogue and deletes the file", func(t *testing.T) {
+		f := startHydrated(t, hydratedOptions{})
+		f.client.Subscribe(f.session())
+		f.client.Must("disposeSession", obj{"channel": f.session()})
+		if f.host.Store().Has(f.session()) {
+			t.Fatal("the session channel remains")
+		}
+		if len(f.deletedFiles()) != 1 {
+			t.Fatalf("deleted = %v", f.deletedFiles())
+		}
+		if got := f.listItems(); len(got) != 0 {
+			t.Fatalf("a disposed session must not come back on the next listing: %v", got)
+		}
+	})
+
+	twin.Run(t, "hydrated-session-lifecycle", "prevents an unloaded session from being recreated or hydrated during deletion", func(t *testing.T) {
+		started := make(chan struct{})
+		finish := make(chan bool)
+		var once sync.Once
+		f := startHydrated(t, hydratedOptions{deleteFile: func(path string) (pi.SessionFileDeletionResult, error) {
+			once.Do(func() { close(started) })
+			ok := <-finish
+			if ok {
+				_ = os.Remove(path)
+			}
+			return pi.SessionFileDeletionResult{OK: ok}, nil
+		}})
+		defer func() {
+			select {
+			case finish <- false:
+			default:
+			}
+		}()
+		uri := f.session()
+		disposed := make(chan *testkit.RPCError, 1)
+		go func() { _, err := f.client.Request("disposeSession", obj{"channel": uri}); disposed <- err }()
+		select {
+		case <-started:
+		case <-time.After(testkit.Timeout):
+			t.Fatal("timed out waiting for durable deletion to start")
+		}
+		f.client.ExpectError("subscribe", obj{"channel": uri}, wire.CodeNotFound)
+		f.client.ExpectError("createSession", obj{"channel": uri}, wire.CodeSessionAlreadyExists)
+
+		finish <- true
+		if err := <-disposed; err != nil {
+			t.Fatal(err)
+		}
+		deleted := f.deletedFiles()
+		if len(deleted) != 1 {
+			t.Fatalf("deleted = %v", deleted)
+		}
+		if _, err := os.Stat(deleted[0]); !os.IsNotExist(err) {
+			t.Fatalf("the deleted session file remains: %v", err)
+		}
+		for _, item := range f.listItems() {
+			if item["resource"] == uri {
+				t.Fatal("the disposed session is still listed")
+			}
+		}
+	})
+}
+
+func TestResumingAHydratedSession(t *testing.T) {
+	twin.Run(t, "hydrated-session-lifecycle", "starts an agent on the first turn and prompts it", func(t *testing.T) {
+		f := startHydrated(t, hydratedOptions{})
+		f.client.Subscribe(f.chat())
+		if got := f.backend.promptList(); len(got) != 0 {
+			t.Fatalf("browsing history must not start an agent: %v", got)
+		}
+		f.turnStarted("t-resume", "continue please")
+		testkit.Eventually(t, "the resumed prompt to reach the backend", func() bool { return len(f.backend.promptList()) == 1 })
+		if got := f.backend.promptList(); !reflect.DeepEqual(got, []string{"continue please"}) {
+			t.Fatalf("prompts = %v", got)
+		}
+		testkit.Eventually(t, "the resumed turn to settle", func() bool { return f.host.Store().Chat(f.chat()).ActiveTurn == nil })
+	})
+
+	twin.Run(t, "hydrated-session-lifecycle", "resumes onto the existing transcript rather than a fresh one", func(t *testing.T) {
+		f := startHydrated(t, hydratedOptions{})
+		f.client.Subscribe(f.chat())
+		before := len(f.host.Store().Chat(f.chat()).Turns)
+		f.turnStarted("t-append", "and again")
+		testkit.Eventually(t, "the resumed prompt to reach the backend", func() bool { return len(f.backend.promptList()) == 1 })
+		testkit.Eventually(t, "the resumed turn to append after history", func() bool { return len(f.host.Store().Chat(f.chat()).Turns) == before+1 })
+		turns := f.host.Store().Chat(f.chat()).Turns
+		if turns[0].Message.Text != "Read note.txt" || turns[len(turns)-1].Message.Text != "and again" {
+			t.Fatalf("turns = %+v", turnShapes(turns))
+		}
+	})
+}
+
+func TestModelSelectionOnAHydratedSession(t *testing.T) {
+	twin.Run(t, "hydrated-session-lifecycle", "seeds the picker from the model the session was using", func(t *testing.T) {
+		f := startHydrated(t, hydratedOptions{})
+		chat := snapshotState[ahptypes.ChatState](t, f.client, f.chat())
+		if chat.Draft == nil || chat.Draft.Model == nil || chat.Draft.Model.Id != "fixture/test-model" {
+			t.Fatalf("draft = %+v", chat.Draft)
+		}
+	})
+}
+
+func TestRenamingAHydratedSession(t *testing.T) {
+	twin.Run(t, "hydrated-session-lifecycle", "persists the name into the session file", func(t *testing.T) {
+		f := startHydrated(t, hydratedOptions{})
+		f.client.Subscribe(f.session())
+		f.client.Dispatch(f.session(), obj{"type": "session/titleChanged", "title": "Archived work"})
+		f.client.Ping()
+		if got := f.host.Store().Session(f.session()).Title; got != "Archived work" {
+			t.Fatalf("title = %q", got)
+		}
+		testkit.Eventually(t, "the name to reach the file", func() bool {
+			file, _ := pi.NewCatalogue(f.root).FindSessionFile(f.sessionID)
+			if file == "" {
+				return false
+			}
+			m, err := pisession.Open(file)
+			return err == nil && m.SessionName() == "Archived work"
+		})
+	})
+}