fix(session): unbreak CI - small-cap trim fixtures + incremental redaction

TestSave_TrimsOversizedSession timed out at 10m in CI: the 40 MiB
fixture forced redact.RedactSecrets (20+ regexes) over the whole
transcript on save, and saveLocked re-redacts the ENTIRE history on
every save - O(history) per write, O(n^2) over a session's life.

- MaxSessionFileBytes is now a var (comment: production treats it as
  fixed) so cap-trimming tests use a 64 KiB cap with tiny fixtures
  instead of multi-MiB transcripts; the oversized trim tests drop from
  ~25s to <0.1s and the session package from ~42s to ~1.5s.
- Real production win behind the same failure: sessions are append-only,
  so saveLocked now redacts only messages at or beyond a persisted
  RedactBoundary instead of the full transcript on every save. Old
  files default to 0 (= redact all once); the boundary is set to the
  surviving message count before the final marshal so it persists.
- New TestSave_IncrementalRedaction pins the boundary behavior;
  small-cap fixtures keep identical trim semantics coverage.

Author: jkyberneees

internal/session/session.go

@@ -35,7 +35,9 @@ import (
 // MaxSessionFileBytes caps the on-disk size of a session file that Load will
 // read into memory. This prevents a tampered or corrupted multi-gigabyte
 // session file from causing an OOM when any caller loads it.
-const MaxSessionFileBytes = 32 * 1024 * 1024 // 32 MiB
+// It is a var, not a const, so tests can temporarily shrink it instead of
+// building multi-MiB fixtures — production code should treat it as fixed.
+var MaxSessionFileBytes = 32 * 1024 * 1024 // 32 MiB
 
 // ── Types ──────────────────────────────────────────────────────────────
 
@@ -52,6 +54,14 @@ type Session struct {
 	Sandbox   bool          `json:"sandbox"`              // was sandboxed — auto-apply on resume
 	Messages  []llm.Message `json:"messages"`             // full conversation history
 	Buffer    []string      `json:"buffer,omitempty"`     // last N turn summaries (memory tier 2)
+
+	// RedactBoundary records how many leading messages have already been
+	// secret-redacted by a previous save. Redacting the full transcript on
+	// every save is O(history) per write — O(n²) over a session's life —
+	// and dominates save time on long sessions (20+ regexes over tens of
+	// MB). Sessions are append-only, so only messages at or beyond the
+	// boundary need scanning. Old files default to 0 (= redact all once).
+	RedactBoundary int `json:"redact_boundary,omitempty"`
 }
 
 // ── Store ──────────────────────────────────────────────────────────────
@@ -355,13 +365,22 @@ func (s *Store) saveLocked(sess *Session) error {
 		return fmt.Errorf("session: refusing unsafe save: %w", err)
 	}
 
-	// Redact secrets from all messages and the task label before writing to
-	// disk. This is defense-in-depth: the loop engine already redacts tool
-	// outputs, but this catches any secrets that slipped through
-	// (e.g. LLM hallucinations, direct API usage, or the first user prompt
-	// stored as the session title).
+	// Redact secrets before writing to disk. This is defense-in-depth: the
+	// loop engine already redacts tool outputs, but this catches any secrets
+	// that slipped through (e.g. LLM hallucinations, direct API usage, or
+	// the first user prompt stored as the session title). Sessions are
+	// append-only, so only messages at or beyond sess.RedactBoundary are
+	// scanned — messages already redacted by a previous save are not
+	// re-scanned (see the field comment for the O(n²) rationale).
 	sess.Task = redact.RedactSecrets(sess.Task)
-	for i := range sess.Messages {
+	boundary := sess.RedactBoundary
+	if boundary < 0 {
+		boundary = 0
+	}
+	if boundary > len(sess.Messages) {
+		boundary = len(sess.Messages)
+	}
+	for i := boundary; i < len(sess.Messages); i++ {
 		sess.Messages[i].Content = redact.RedactSecrets(sess.Messages[i].Content)
 		sess.Messages[i].ReasoningContent = redact.RedactSecrets(sess.Messages[i].ReasoningContent)
 	}
@@ -377,8 +396,9 @@ func (s *Store) saveLocked(sess *Session) error {
 	// the most recent turns, mirroring the loop's trim semantics) until the
 	// serialized form fits.
 	if len(data) > MaxSessionFileBytes {
-		data, err = s.trimToFileCapLocked(sess, data)
-		if err != nil {
+		// The trim's own marshaled form is discarded: the final marshal
+		// below recomputes it after RedactBoundary is updated.
+		if _, err = s.trimToFileCapLocked(sess, data); err != nil {
 			return err
 		}
 		if s.trimWarned == nil {
@@ -389,6 +409,15 @@ func (s *Store) saveLocked(sess *Session) error {
 			fmt.Fprintf(os.Stderr, "odek: warning: session %s exceeded %d bytes on write — oldest messages trimmed to stay within the load cap\n", sess.ID, MaxSessionFileBytes)
 		}
 	}
+	// Every surviving message is now redacted: those before the boundary by
+	// earlier saves, the rest just now — and trimming only removes messages,
+	// so the boundary is simply the surviving count. Set it before the final
+	// marshal so it is actually persisted.
+	sess.RedactBoundary = len(sess.Messages)
+	data, err = json.Marshal(sess)
+	if err != nil {
+		return fmt.Errorf("session: marshal: %w", err)
+	}
 
 	if err := fsatomic.WriteFile(s.path(sess.ID), data, 0600); err != nil {
 		return fmt.Errorf("session: write: %w", err)
@@ -472,7 +501,7 @@ func (s *Store) Load(id string) (*Session, error) {
 	if err != nil {
 		return nil, fmt.Errorf("session: load %q: %w", id, err)
 	}
-	if info.Size() > MaxSessionFileBytes {
+	if info.Size() > int64(MaxSessionFileBytes) {
 		return nil, fmt.Errorf("session: load %q: file too large (%d bytes, max %d)", id, info.Size(), MaxSessionFileBytes)
 	}
 	data, err := os.ReadFile(s.path(id))

internal/session/session_savecap_test.go

@@ -43,9 +43,20 @@ func TestSave_IndexWriteError(t *testing.T) {
 	}
 }
 
+// withFileCap temporarily shrinks MaxSessionFileBytes so cap-trimming tests
+// can use small fixtures instead of multi-MiB transcripts (which made the
+// session suite time out in CI).
+func withFileCap(t *testing.T, n int) {
+	t.Helper()
+	orig := MaxSessionFileBytes
+	MaxSessionFileBytes = n
+	t.Cleanup(func() { MaxSessionFileBytes = orig })
+}
+
 // TestTrimToFileCap_NothingDroppable covers the degenerate break branch: a
 // single system message with nothing left to drop is returned as-is.
 func TestTrimToFileCap_NothingDroppable(t *testing.T) {
+	withFileCap(t, 64<<10)
 	store, err := NewStoreWithDir(t.TempDir())
 	if err != nil {
 		t.Fatalf("NewStoreWithDir() error: %v", err)
@@ -71,6 +82,7 @@ func TestTrimToFileCap_NothingDroppable(t *testing.T) {
 // an assistant tool_calls message is dropped together with its tool results,
 // and the trim ends once the re-marshaled session fits.
 func TestTrimToFileCap_DropsToolGroups(t *testing.T) {
+	withFileCap(t, 64<<10)
 	store, err := NewStoreWithDir(t.TempDir())
 	if err != nil {
 		t.Fatalf("NewStoreWithDir() error: %v", err)
@@ -107,3 +119,48 @@ func TestTrimToFileCap_DropsToolGroups(t *testing.T) {
 		}
 	}
 }
+
+// TestSave_IncrementalRedaction verifies secrets are redacted only in
+// messages at or beyond the persisted RedactBoundary: the first save redacts
+// everything, later saves scan only newly appended messages.
+func TestSave_IncrementalRedaction(t *testing.T) {
+	store, err := NewStoreWithDir(t.TempDir())
+	if err != nil {
+		t.Fatalf("NewStoreWithDir() error: %v", err)
+	}
+	secret1 := "sk-" + strings.Repeat("a1", 20)
+	secret2 := "sk-" + strings.Repeat("b2", 20)
+
+	sess, err := store.Create([]llm.Message{
+		{Role: "system", Content: "you are odek"},
+		{Role: "user", Content: "here is my key " + secret1},
+	}, "test", "redact boundary")
+	if err != nil {
+		t.Fatalf("Create() error: %v", err)
+	}
+	loaded, err := store.Load(sess.ID)
+	if err != nil {
+		t.Fatalf("Load() error: %v", err)
+	}
+	if !strings.Contains(loaded.Messages[1].Content, "[REDACTED]") {
+		t.Errorf("secret in first save not redacted: %q", loaded.Messages[1].Content)
+	}
+	if loaded.RedactBoundary != len(loaded.Messages) {
+		t.Errorf("RedactBoundary = %d, want %d after first save", loaded.RedactBoundary, len(loaded.Messages))
+	}
+
+	loaded.Messages = append(loaded.Messages, llm.Message{Role: "assistant", Content: "try " + secret2})
+	if err := store.Save(loaded); err != nil {
+		t.Fatalf("Save() error: %v", err)
+	}
+	reloaded, err := store.Load(sess.ID)
+	if err != nil {
+		t.Fatalf("Load() after second save: %v", err)
+	}
+	if !strings.Contains(reloaded.Messages[2].Content, "[REDACTED]") {
+		t.Errorf("secret in appended message not redacted: %q", reloaded.Messages[2].Content)
+	}
+	if reloaded.RedactBoundary != len(reloaded.Messages) {
+		t.Errorf("RedactBoundary = %d, want %d after second save", reloaded.RedactBoundary, len(reloaded.Messages))
+	}
+}

internal/session/session_test.go

@@ -1291,10 +1291,12 @@ func TestBuildConversationText(t *testing.T) {
 // trailing messages must survive; the oldest turns are dropped.
 func TestSave_TrimsOversizedSession(t *testing.T) {
 	store := newTestStore(t)
+	withFileCap(t, 64<<10)
 
-	// ~10 MiB per message × 4 messages ≈ 40 MiB serialized — past the 32 MiB
-	// cap. Few large messages keep the trim loop's re-marshal cycles cheap.
-	big := strings.Repeat("x", 10<<20)
+	// 20 KiB per message × 4 messages ≈ 80 KiB serialized — past the 64 KiB
+	// test cap. Few large messages keep the trim loop's re-marshal cycles
+	// cheap; the small cap (see withFileCap) keeps this fast in CI.
+	big := strings.Repeat("x", 20<<10)
 	msgs := []llm.Message{{Role: "system", Content: "you are odek"}}
 	for i := 0; i < 4; i++ {
 		role := "user"
@@ -1318,7 +1320,7 @@ func TestSave_TrimsOversizedSession(t *testing.T) {
 	if err != nil {
 		t.Fatalf("stat session file: %v", err)
 	}
-	if info.Size() > MaxSessionFileBytes {
+	if info.Size() > int64(MaxSessionFileBytes) {
 		t.Errorf("session file size = %d, exceeds MaxSessionFileBytes %d", info.Size(), MaxSessionFileBytes)
 	}
 
@@ -1352,8 +1354,10 @@ func TestSave_TrimsOversizedSession(t *testing.T) {
 // transcript never starts with an orphaned tool message.
 func TestSave_TrimKeepsToolGroupsIntact(t *testing.T) {
 	store := newTestStore(t)
+	withFileCap(t, 64<<10)
 
-	big := strings.Repeat("y", 7<<20)
+	// 6 × 12 KiB ≈ 72 KiB — past the 64 KiB test cap.
+	big := strings.Repeat("y", 12<<10)
 	msgs := []llm.Message{{Role: "system", Content: "you are odek"}}
 	for i := 0; i < 3; i++ {
 		call := llm.Message{Role: "assistant", Content: big}