Keep trimmed legacy host task readback explicitly incomplete

This commit is contained in:
2026-11-07 16:40:44 +00:00
parent 63a89ec99c
commit d0f616babc
3 changed files with 154 additions and 0 deletions
+3
View File
@@ -639,6 +639,9 @@ func (c *Chat) Shells(ctx context.Context, id string) ([]protocol.ChatShell, err
s.enrichShellStarts()
s.mu.Lock()
defer s.mu.Unlock()
if p := s.proc; p != nil && p.link != nil && p.link.tasksIncomplete.Load() {
return nil, errors.New("Claude Code background task readback is incomplete: the legacy host trimmed replay without an authoritative task snapshot")
}
result := []protocol.ChatShell{}
for _, snapshot := range s.shells {
if snapshot.shell.Status == protocol.ChatShellRunning {
+10
View File
@@ -100,6 +100,8 @@ type hostLink struct {
record claudehost.Record
// Immutable capability of this attachment; old hosts cannot protect idle background tasks.
tasksKnown bool
// A legacy host may have trimmed identities this client never observed.
tasksIncomplete atomic.Bool
mu sync.Mutex
conn *claudehost.Conn
@@ -169,6 +171,7 @@ func (s *session) startHosted(ctx context.Context, args []string, mode string, e
link := &hostLink{dir: c.hostDir, conn: conn, tasksKnown: status.Tasks != nil, record: claudehost.Record{
SessionID: s.id, HostPID: status.HostPID, ClaudePID: status.ClaudePID, Socket: paths.Socket,
}}
link.tasksIncomplete.Store(status.Tasks == nil && status.Base > 0)
p := newProcess(s, mode)
p.link = link
p.markReady()
@@ -243,6 +246,7 @@ func (c *Chat) connectHostContext(ctx context.Context, record claudehost.Record)
p.link = &hostLink{dir: c.hostDir, conn: conn, committed: status.Acked, tasksKnown: status.Tasks != nil, record: claudehost.Record{
SessionID: record.SessionID, HostPID: status.HostPID, ClaudePID: status.ClaudePID, Socket: record.Socket,
}}
p.link.tasksIncomplete.Store(status.Tasks == nil && status.Base > 0)
p.stderr.WriteString(status.Stderr)
p.models, p.account, p.appliedModel = models, account, status.Model
plan := replayPlan{base: status.Base, silentUntil: status.Acked, catchUpEnd: status.End, pending: map[string]bool{}, busyAtAcked: status.BusyAtAcked, restore: true, tasks: status.Tasks}
@@ -346,6 +350,9 @@ func (p *process) readHost(conn *claudehost.Conn, plan replayPlan) {
catchUpReady := func() {
if !tasksReconciled {
s.reconcileHostTasks(plan.tasks)
if plan.tasks != nil {
p.link.tasksIncomplete.Store(false)
}
tasksReconciled = true
}
p.markReady()
@@ -501,6 +508,9 @@ func (p *process) hostLost(conn *claudehost.Conn, cause error) (*claudehost.Conn
}
next, status, err := claudehost.Attach(link.record.Socket, committed, hostAttachTimeout)
if err == nil {
if status.Tasks == nil && status.Base > committed {
link.tasksIncomplete.Store(true)
}
link.mu.Lock()
link.conn = next
link.mu.Unlock()
+141
View File
@@ -0,0 +1,141 @@
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)
}
}