fix(sessions): preserve image attachment summaries on resume

internal/acp/agent.go

@@ -528,8 +528,6 @@ func (a *Agent) runTurn(ctx context.Context, sess *acpSession, userText string,
 	queue := func(input sessions.AppendEventInput) {
 		pendingEvents = append(pendingEvents, input)
 	}
-	queue(messageEvent("user", userText))
-
 	visionCache := make(map[string]bool)
 	var visionCacheMu sync.Mutex
 	supportsVision := func(modelID string) bool {
@@ -553,6 +551,9 @@ func (a *Agent) runTurn(ctx context.Context, sess *acpSession, userText string,
 		effectivePrompt = fmt.Sprintf("[Note: %s]\n\n%s", msg, userText)
 		images = nil
 	}
+	// Match the TUI: only images actually sent to the model enter history.
+	attachments := sessions.MessageAttachments{Images: len(images)}
+	queue(messageEvent("user", userText, attachments))
 
 	opts := agent.Options{
 		Cwd:            sess.cwd,
@@ -593,7 +594,7 @@ func (a *Agent) runTurn(ctx context.Context, sess *acpSession, userText string,
 	agentPrompt := buildPrompt(sess.snapshotHistory(), effectivePrompt)
 	result, runErr := a.deps.RunAgent(ctx, agentPrompt, provider, opts)
 	if result.FinalAnswer != "" {
-		queue(messageEvent("assistant", result.FinalAnswer))
+		queue(messageEvent("assistant", result.FinalAnswer, sessions.MessageAttachments{}))
 	}
 	reason, stopErr := stopReasonFor(result, runErr)
 	if stopErr != nil {
@@ -614,7 +615,7 @@ func (a *Agent) runTurn(ctx context.Context, sess *acpSession, userText string,
 	// one file write, which is the contiguity restored here — not a disk
 	// transaction, and not a promise about crashes mid-fsync. Reported by @jatmn.
 	persistenceErr := a.persistTurn(sess.id, pendingEvents)
-	sess.appendHistory(turnRecord{user: userText, assistant: result.FinalAnswer})
+	sess.appendHistory(turnRecord{user: attachments.WithContent(userText), assistant: result.FinalAnswer})
 	a.warnPersistence(
 		note,
 		"save session history",
@@ -930,10 +931,14 @@ func (a *Agent) persistTurn(sessionID string, inputs []sessions.AppendEventInput
 	return err
 }
 
-func messageEvent(role, content string) sessions.AppendEventInput {
+func messageEvent(role, content string, attachments sessions.MessageAttachments) sessions.AppendEventInput {
+	payload := map[string]any{"role": role, "content": content}
+	if role == "user" && (attachments.Images > 0 || attachments.Documents > 0) {
+		payload["attachments"] = attachments
+	}
 	return sessions.AppendEventInput{
 		Type:    sessions.EventMessage,
-		Payload: map[string]any{"role": role, "content": content},
+		Payload: payload,
 	}
 }
 
@@ -1094,14 +1099,16 @@ func (a *Agent) loadHistory(sessionID string, requireHistoryLog bool) ([]turnRec
 			continue
 		}
 		var msg struct {
-			Role    string `json:"role"`
-			Content string `json:"content"`
+			Role        string                      `json:"role"`
+			Content     string                      `json:"content"`
+			Attachments sessions.MessageAttachments `json:"attachments"`
 		}
 		if json.Unmarshal(raw, &msg) != nil {
 			continue
 		}
 		switch msg.Role {
 		case "user":
+			msg.Content = msg.Attachments.WithContent(msg.Content)
 			messages = append(messages, persistedMessage{eventID: persistedMessageIdentity(sessionID, e), role: msg.Role, content: msg.Content})
 			if havePending {
 				records = append(records, turnRecord{user: pendingUser})

internal/acp/agent_test.go

@@ -960,7 +960,11 @@ func TestACPHardTurnFailureDoesNotCommitHistory(t *testing.T) {
 		t.Fatal(err)
 	}
 	if err := h.client.Call(ctx, MethodSessionPrompt, PromptParams{
-		SessionID: created.SessionID, Prompt: []ContentBlock{TextBlock("failed question")},
+		SessionID: created.SessionID,
+		Prompt: []ContentBlock{
+			TextBlock("failed question"),
+			ImageBlock(base64.StdEncoding.EncodeToString([]byte("failed image")), "image/png"),
+		},
 	}, &PromptResult{}); err == nil {
 		t.Fatal("hard RunAgent failure was reported as a successful turn")
 	}

internal/acp/image_history_test.go

@@ -0,0 +1,181 @@
+package acp
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/Twigpine/zero/internal/agent"
+	"github.com/Twigpine/zero/internal/config"
+	"github.com/Twigpine/zero/internal/providermodeldiscovery"
+	"github.com/Twigpine/zero/internal/sessions"
+	"github.com/Twigpine/zero/internal/zeroruntime"
+)
+
+func TestACPImageAttachmentHistory(t *testing.T) {
+	for _, tc := range []struct {
+		name          string
+		text          string
+		images        int
+		withoutVision bool
+		want          string
+	}{
+		{name: "image only", images: 1, want: "[1 image]"},
+		{name: "text and images", text: "compare these", images: 2, want: "compare these [2 images]"},
+		{name: "ignored by model", images: 1, withoutVision: true, want: ""},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			deps := testDeps(t)
+			deps.DiscoverModels = func(context.Context, config.ProviderProfile) ([]providermodeldiscovery.Model, error) {
+				modalities := []string{"text", "image"}
+				if tc.withoutVision {
+					modalities = []string{"text"}
+				}
+				return []providermodeldiscovery.Model{{ID: "fake-model", InputModalities: modalities}}, nil
+			}
+			type observedTurn struct {
+				prompt string
+				images int
+			}
+			turns := make(chan observedTurn, 8)
+			deps.RunAgent = func(_ context.Context, prompt string, _ zeroruntime.Provider, opts agent.Options) (agent.Result, error) {
+				turns <- observedTurn{prompt: prompt, images: len(opts.Images)}
+				return agent.Result{FinalAnswer: "received"}, nil
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+			defer cancel()
+			workspace := t.TempDir()
+			h := newHarness(t, deps)
+			defer h.stop()
+			var created NewSessionResult
+			if err := h.client.Call(ctx, MethodSessionNew, NewSessionParams{Cwd: workspace}, &created); err != nil {
+				t.Fatal(err)
+			}
+			const imageData = "image-history-bytes-not-for-storage"
+			encoded := base64.StdEncoding.EncodeToString([]byte(imageData))
+			var blocks []ContentBlock
+			if tc.text != "" {
+				blocks = append(blocks, TextBlock(tc.text))
+			}
+			for range tc.images {
+				blocks = append(blocks, ImageBlock(encoded, "image/png"))
+			}
+			if err := h.client.Call(ctx, MethodSessionPrompt, PromptParams{SessionID: created.SessionID, Prompt: blocks}, &PromptResult{}); err != nil {
+				t.Fatal(err)
+			}
+			live := <-turns
+			wantLiveImages := tc.images
+			if tc.withoutVision {
+				wantLiveImages = 0
+			}
+			if live.images != wantLiveImages {
+				t.Fatalf("live images = %d, want %d", live.images, wantLiveImages)
+			}
+			events, err := deps.Store.ReadEvents(created.SessionID)
+			if err != nil || len(events) < 2 {
+				t.Fatalf("read completed turn: events=%+v err=%v", events, err)
+			}
+			var user struct {
+				Role        string `json:"role"`
+				Content     string `json:"content"`
+				Attachments struct {
+					Images int `json:"images"`
+				} `json:"attachments"`
+			}
+			if err := json.Unmarshal(events[0].Payload, &user); err != nil {
+				t.Fatal(err)
+			}
+			if user.Role != "user" || user.Content != tc.text || user.Attachments.Images != wantLiveImages {
+				t.Errorf("stored user event = %s, want original text and attachments.images=%d", events[0].Payload, wantLiveImages)
+			}
+			for _, event := range events {
+				if bytes.Contains(event.Payload, []byte(encoded)) || bytes.Contains(event.Payload, []byte(imageData)) {
+					t.Errorf("image data leaked into session event: %s", event.Payload)
+				}
+			}
+			followUp := func(t *testing.T, client *clientHarness) {
+				t.Helper()
+				if err := client.client.Call(ctx, MethodSessionPrompt, PromptParams{
+					SessionID: created.SessionID, Prompt: []ContentBlock{TextBlock("what did I send?")},
+				}, &PromptResult{}); err != nil {
+					t.Fatal(err)
+				}
+				got := <-turns
+				if want := "User: " + tc.want + "\n"; !strings.Contains(got.prompt, want) {
+					t.Errorf("seeded prompt missing user history %q: %q", want, got.prompt)
+				}
+				if got.images != 0 {
+					t.Errorf("historical images reattached: %d", got.images)
+				}
+			}
+			followUp(t, h)
+			h.stop()
+			// Fresh agents and stores reproduce a process restart, with no shared
+			// in-memory history to hide a missing attachment in the event log.
+			for _, method := range []string{MethodSessionLoad, MethodSessionResume} {
+				t.Run(method, func(t *testing.T) {
+					restoredDeps := deps
+					restoredDeps.Store = sessions.NewStore(sessions.StoreOptions{RootDir: deps.Store.RootDir})
+					loader := newHarness(t, restoredDeps)
+					defer loader.stop()
+					if err := loader.client.Call(ctx, method, LoadSessionParams{SessionID: created.SessionID, Cwd: workspace}, &LoadSessionResult{}); err != nil {
+						t.Fatal(err)
+					}
+					if method == MethodSessionLoad {
+						select {
+						case update := <-loader.notifications:
+							if update.SessionUpdate != UpdateUserMessageChunk || update.Content.Text != tc.want {
+								t.Errorf("replayed user = %+v, want %q", update, tc.want)
+							}
+						case <-ctx.Done():
+							t.Fatal("user turn was not replayed")
+						}
+					} else {
+						select {
+						case update := <-loader.notifications:
+							t.Errorf("resume replayed transcript: %+v", update)
+						default:
+						}
+					}
+					followUp(t, loader)
+				})
+			}
+		})
+	}
+}
+
+func TestACPAttachmentHistoryReadsExistingSessionMessages(t *testing.T) {
+	deps := testDeps(t)
+	meta, err := deps.Store.Create(sessions.CreateInput{SessionID: "attachment-compatibility", Cwd: t.TempDir()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i, payload := range []string{
+		`{"role":"user","content":"old text"}`,
+		`{"role":"user","content":"","attachments":{"images":1,"documents":2}}`,
+		`{"role":"user","content":"still text","attachments":{"images":-1,"documents":1.5}}`,
+		`{"role":"assistant","content":"answer","attachments":{"images":1}}`,
+	} {
+		if _, err := deps.Store.AppendEvent(meta.SessionID, sessions.AppendEventInput{Type: sessions.EventMessage, Payload: json.RawMessage(payload)}); err != nil {
+			t.Fatalf("append message %d: %v", i, err)
+		}
+	}
+	a := &Agent{deps: deps}
+	_, messages, _, err := a.loadHistory(meta.SessionID, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{"old text", "[1 image] [2 documents]", "still text", "answer"}
+	if len(messages) != len(want) {
+		t.Fatalf("messages = %+v", messages)
+	}
+	for i, text := range want {
+		if messages[i].content != text {
+			t.Errorf("message %d = %q, want %q", i, messages[i].content, text)
+		}
+	}
+}

internal/cli/exec.go

@@ -434,6 +434,8 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 		}
 		images = nil
 	}
+	// Match the TUI: only images actually sent to the model enter history.
+	attachments := sessions.MessageAttachments{Images: len(images)}
 	runReasoningEffort := options.reasoningEffort
 	if options.useSpec && options.specReasoningEffort != "" {
 		runReasoningEffort = options.specReasoningEffort
@@ -614,10 +616,14 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 	sessionRecorder := execSessionRecorder{prepared: preparedSession}
 	// Surface a best-effort session-recording failure once, on every exit path.
 	defer sessionRecorder.warnIfRecordingFailed(stderr)
-	sessionRecorder.append(sessions.EventMessage, map[string]any{
+	userPayload := map[string]any{
 		"role":    "user",
 		"content": prompt,
-	})
+	}
+	if attachments.Images > 0 {
+		userPayload["attachments"] = attachments
+	}
+	sessionRecorder.append(sessions.EventMessage, userPayload)
 
 	// OnAskUser is intentionally left unset: headless runs have no interactive
 	// user, so ask_user degrades to a "proceed with your best assumption" result