package codex import ( "context" "encoding/json" "testing" "git.a-wan.net/alan/pipelines/internal/protocol" ) func TestCompactionHistoryReadbackHasNoSyntheticToolOrRunningGuess(t *testing.T) { c := modelTestChat(t, func(method string, _ json.RawMessage) any { if method != "thread/turns/list" { t.Errorf("unexpected method: %s", method) } return json.RawMessage(`{"data":[{"id":"turn","status":"inProgress","items":[{"type":"contextCompaction","id":"compact"}]}],"nextCursor":null}`) }) page, err := c.Messages(context.Background(), fixtureThread, 50, "") if err != nil || len(page.Messages) != 0 { t.Fatalf("synthetic compaction transcript: %+v %v", page, err) } readback, err := c.latestTurn(context.Background(), fixtureThread) if err != nil || !activeTurn(readback.turn) || len(c.compactions) != 0 { t.Fatal("history guessed running compaction") } } func TestCompactionTerminalReadbackSettlesRetainedActivity(t *testing.T) { c := modelTestChat(t, func(method string, _ json.RawMessage) any { if method != "thread/turns/list" { t.Errorf("unexpected method: %s", method) } return json.RawMessage(`{"data":[{"id":"turn","status":"completed","items":[{"type":"contextCompaction","id":"compact"}]}],"nextCursor":null}`) }) c.mu.Lock() c.turns[fixtureThread] = "turn" c.mu.Unlock() c.emit(protocol.ChatEventFrame{SessionID: fixtureThread, NativeTurnID: "turn", Kind: protocol.ChatEventCompaction, Compaction: &protocol.ChatCompaction{ID: "compact", Status: "running"}}) ctx, cancel := context.WithCancel(context.Background()) defer cancel() var frames []protocol.ChatEventFrame err := c.Stream(ctx, fixtureThread, nil, func(f protocol.ChatEventFrame) error { frames = append(frames, f) if f.Step != nil && f.Step.Status == protocol.ChatStepEnded { cancel() } return nil }) if err != context.Canceled || len(frames) != 2 || frames[0].Compaction == nil || frames[1].Step == nil || len(c.compactions) != 0 { t.Fatalf("terminal readback: %+v %v", frames, err) } } // Typed schema fixtures from openai/codex@c465563aa9626d99420062135b187d299f904f81: // app-server-protocol/schema/typescript/v2/{ThreadItem,ItemStartedNotification, // ItemCompletedNotification,ContextCompactedNotification}.ts and // app-server-protocol/src/protocol/common.rs. No live compaction was triggered. func TestCompactionNotificationsAreActivityNotTools(t *testing.T) { c := &Chat{subs: map[string]map[chan protocol.ChatEventFrame]struct{}{}, turns: map[string]string{"thread": "turn_new"}} ch := c.subscribe("thread") other := c.subscribe("other") notify := func(method, turnID, itemID string) { raw, _ := json.Marshal(map[string]any{"threadId": "thread", "turnId": turnID, "item": map[string]any{"id": itemID, "type": "contextCompaction"}}) c.handleNotification(rpcMessage{Method: method, Params: raw}) } notify("item/started", "turn_old", "old") if len(ch) != 0 { t.Fatal("old-turn compaction surfaced") } notify("item/started", "turn_new", "compact_1") f := <-ch if f.Kind != protocol.ChatEventCompaction || f.MessageID != "" || f.Part != nil || f.Step != nil || f.Compaction.ID != "compact_1" || f.NativeTurnID != "turn_new" || f.Compaction.Status != "running" { t.Fatalf("start: %+v", f) } if len(other) != 0 { t.Fatal("cross-thread compaction leaked") } late := c.subscribe("thread") if replay := <-late; replay.Compaction == nil || replay.Compaction.ID != "compact_1" { t.Fatalf("late watcher replay: %+v", replay) } notify("item/started", "turn_new", "compact_2") <-ch notify("item/completed", "turn_new", "compact_1") if len(ch) != 0 { t.Fatal("old item completion cleared new compaction") } // Legacy completion is unkeyed; ignore it while a modern keyed item runs. notify("thread/compacted", "turn_new", "") if len(ch) != 0 { t.Fatal("legacy duplicate cleared keyed compaction") } notify("item/completed", "turn_new", "compact_2") f = <-ch if f.Compaction.Status != "completed" || c.turns["thread"] != "turn_new" { t.Fatal("compaction completion ended native turn") } if len(c.compactions) != 0 { t.Fatal("completed compaction retained") } if _, ok := (item{Type: "contextCompaction", ID: "historic"}).chatMessage("thread"); ok { t.Fatal("compaction history became a fake tool/message") } notify("thread/compacted", "turn_old", "") if len(ch) != 0 { t.Fatal("old legacy turn completion surfaced") } notify("thread/compacted", "turn_new", "") if f := <-ch; f.Compaction.Status != "completed" { t.Fatal("typed legacy completion unsupported") } // Turn terminal state blocks even a late same-turn start. c.emit(stepFrame("thread", protocol.ChatStepEnded, "turn_new")) <-ch notify("item/started", "turn_new", "late_old") if len(ch) != 0 { t.Fatal("terminal turn regained compaction") } }