package claude import ( "context" "encoding/json" "net" "os" "path/filepath" "testing" "time" "git.a-wan.net/alan/pipelines/internal/claudehost" ) func taskReadbackFixture(t *testing.T, serve func(net.Listener, <-chan struct{})) (*Chat, *process) { t.Helper() base, err := os.MkdirTemp("/tmp", "pcr") if err != nil { t.Fatal(err) } socket := filepath.Join(base, "host.sock") listener, err := net.Listen("unix", socket) if err != nil { os.RemoveAll(base) t.Fatal(err) } stop := make(chan struct{}) done := make(chan struct{}) go func() { defer close(done); serve(listener, stop) }() chat := newChat(context.Background()) p, conn, plan := chat.connectHost(claudehost.Record{SessionID: "completeness-session", Socket: socket}) if p == nil { close(stop) listener.Close() os.RemoveAll(base) chat.Close() t.Fatal("readback fixture did not attach") } s := p.session s.mu.Lock() s.proc = p s.mu.Unlock() go p.readHost(conn, plan) t.Cleanup(func() { p.detach() close(stop) listener.Close() <-done chat.Close() os.RemoveAll(base) }) return chat, p } func serveTaskReadback(conn net.Conn, base, end int64, tasks *[]claudehost.Task) error { var attach claudehost.Frame if err := json.NewDecoder(conn).Decode(&attach); err != nil { return err } out := json.NewEncoder(conn) if err := out.Encode(claudehost.Frame{Op: claudehost.OpStatus, Status: &claudehost.Status{SessionID: "completeness-session", Base: base, Acked: base, End: end, Init: json.RawMessage(`{"models":[{"value":"fixture"}]}`), Tasks: tasks}}); err != nil { return err } return out.Encode(claudehost.Frame{Op: claudehost.OpOut, Offset: base, End: end, Data: json.RawMessage(`{"type":"system","subtype":"status"}`)}) } func TestLegacyTaskReadbackDistinguishesTrimmedUnknownFromCompleteIdle(t *testing.T) { empty := []claudehost.Task{} for _, tc := range []struct { name string base int64 tasks *[]claudehost.Task unknown bool }{ {name: "trimmed legacy is unknown", base: 200, unknown: true}, {name: "full legacy replay is complete", base: 0}, {name: "new authoritative snapshot survives trim", base: 200, tasks: &empty}, } { t.Run(tc.name, func(t *testing.T) { chat, _ := taskReadbackFixture(t, func(listener net.Listener, stop <-chan struct{}) { conn, err := listener.Accept() if err != nil { return } defer conn.Close() if serveTaskReadback(conn, tc.base, tc.base+100, tc.tasks) != nil { return } <-stop }) ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() shells, err := chat.Shells(ctx, "completeness-session") if (err != nil) != tc.unknown || len(shells) != 0 { t.Fatalf("incorrect authoritative-empty decision: tasks=%+v err=%v", shells, err) } }) } } func TestLegacyReconnectGapInvalidatesPreviouslyCompleteTaskReadback(t *testing.T) { drop := make(chan struct{}) chat, p := taskReadbackFixture(t, func(listener net.Listener, stop <-chan struct{}) { first, err := listener.Accept() if err != nil { return } if serveTaskReadback(first, 0, 100, nil) != nil { first.Close() return } select { case <-drop: case <-stop: first.Close() return } first.Close() second, err := listener.Accept() if err != nil { return } defer second.Close() if serveTaskReadback(second, 300, 400, nil) != nil { return } <-stop }) ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() if shells, err := chat.Shells(ctx, "completeness-session"); err != nil || len(shells) != 0 { t.Fatalf("initial full replay should be known idle: %+v %v", shells, err) } close(drop) eventually(t, "legacy reconnect gap to make task readback incomplete", func() bool { return p.link.tasksIncomplete.Load() }) if shells, err := chat.Shells(ctx, "completeness-session"); err == nil || len(shells) != 0 { t.Fatalf("missing events became an authoritative empty task set: %+v %v", shells, err) } }