Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

Retry a whole store record when one of its events fails to write

Claudefa61cce6a4d9
diff --git a/cli/beacon/internal/clinesession/collect.go b/cli/beacon/internal/clinesession/collect.go
index f4a8aeb6..43ff9ef8 100644
--- a/cli/beacon/internal/clinesession/collect.go
+++ b/cli/beacon/internal/clinesession/collect.go
@@ -175,13 +175,15 @@ func collectTrace(store *Store, ref TraceRef, state *State, opts CollectOptions,
return false, nil
}
for i, item := range mapped {
- if err := emit(item.Event, opts); err != nil {
- if i > 0 {
- cursor.LastOrder = mapped[i-1].SourceOrder
- }
+ if err := emitEvent(item.Event, opts); err != nil {
return true, err
}
- cursor.LastOrder = item.SourceOrder
+ // A record can map to several events (a prompt and its session.handoff link). The cursor
+ // passes a record only once its last event is written, so a failure partway through retries
+ // the whole record rather than skipping what was left of it.
+ if recordComplete(mapped, i) {
+ cursor.LastOrder = item.SourceOrder
+ }
if pendingHashes != nil {
if h, ok := pendingHashes[item.SourceOrder]; ok {
if cursor.KanbanHashes == nil {
@@ -218,6 +220,9 @@ func kanbanContentHash(r Record) string {
return hex.EncodeToString(h[:])
}
+// emitEvent is emit, swapped by tests to fail a chosen write.
+var emitEvent = emit
+
func emit(event schema.Event, opts CollectOptions) error {
if opts.Print && opts.Out != nil {
data, err := json.Marshal(event)
@@ -235,3 +240,8 @@ func emit(event schema.Event, opts CollectOptions) error {
}
return nil
}
+
+// recordComplete reports whether mapped[i] is the last event of its source record.
+func recordComplete(mapped []MappedEvent, i int) bool {
+ return i+1 == len(mapped) || mapped[i+1].SourceOrder != mapped[i].SourceOrder
+}
diff --git a/cli/beacon/internal/clinesession/partial_test.go b/cli/beacon/internal/clinesession/partial_test.go
new file mode 100644
index 00000000..e58df814
--- /dev/null
+++ b/cli/beacon/internal/clinesession/partial_test.go
@@ -0,0 +1,64 @@
+package clinesession
+
+import (
+ "errors"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/schema"
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/testenv"
+ "github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve"
+)
+
+func TestRecordCompleteWaitsForTheRecordsLastEvent(t *testing.T) {
+ // Record 2 maps to a prompt and its session.handoff link.
+ mapped := []MappedEvent{{SourceOrder: 1}, {SourceOrder: 2}, {SourceOrder: 2}, {SourceOrder: 3}}
+ want := []bool{true, false, true, true}
+ for i := range mapped {
+ if got := recordComplete(mapped, i); got != want[i] {
+ t.Fatalf("recordComplete(%d) = %v, want %v", i, got, want[i])
+ }
+ }
+}
+
+// A sync whose session.handoff write fails after the prompt from the same record was written
+// retries that record, so the link is not lost.
+func TestCollectOnceRetriesARecordWhoseLinkFailedToWrite(t *testing.T) {
+ testenv.SetHome(t, t.TempDir())
+ f := newSweepFixture(t)
+ sessionDir := filepath.Join(f.clineDir, "data", "sessions", "new-1")
+ if err := os.MkdirAll(sessionDir, 0o755); err != nil {
+ t.Fatal(err)
+ }
+ prompt := "Continue the work.\n\n" + asymptoteobserve.HandoffMarker("claude_code", "src-1")
+ writeJSON(t, filepath.Join(sessionDir, "new-1.json"), map[string]interface{}{"task": "Continue", "workspacePath": "/repo"})
+ writeJSON(t, filepath.Join(sessionDir, "new-1.messages.json"), map[string]interface{}{"messages": []interface{}{
+ map[string]interface{}{"role": "user", "content": prompt},
+ }})
+
+ prev := emitEvent
+ t.Cleanup(func() { emitEvent = prev })
+ emitEvent = func(event schema.Event, opts CollectOptions) error {
+ if event.Event.Action == "session.handoff" {
+ return errors.New("disk full")
+ }
+ return prev(event, opts)
+ }
+ if _, err := CollectOnce(f.options()); err == nil {
+ t.Fatal("the failed link write must surface")
+ }
+ emitEvent = prev
+ if _, err := CollectOnce(f.options()); err != nil {
+ t.Fatalf("retry: %v", err)
+ }
+ links := 0
+ for _, e := range f.logLines(t) {
+ if e.Event.Action == "session.handoff" {
+ links++
+ }
+ }
+ if links != 1 {
+ t.Fatalf("session.handoff events after the retry = %d, want 1", links)
+ }
+}
diff --git a/cli/beacon/internal/codexsession/collect.go b/cli/beacon/internal/codexsession/collect.go
index c4e7ddf7..1472b313 100644
--- a/cli/beacon/internal/codexsession/collect.go
+++ b/cli/beacon/internal/codexsession/collect.go
@@ -172,10 +172,8 @@ func collectSession(store *Store, ref SessionRef, state *State, opts CollectOpti
return false, nil
}
for i, item := range mapped {
- if err := emit(item.Event, opts); err != nil {
- if i > 0 {
- cursor.LastLine = mapped[i-1].SourceLine
- }
+ if err := emitEvent(item.Event, opts); err != nil {
+ advanceCursorPartial(cursor, mapped, i)
return true, err
}
summary.EventsEmitted++
@@ -193,6 +191,9 @@ func advanceCursor(cursor *Cursor, ref SessionRef, lines int) {
cursor.ModTimeUnixMS = ref.ModTimeUnixMS
}
+// emitEvent is emit, swapped by tests to fail a chosen write.
+var emitEvent = emit
+
func emit(event schema.Event, opts CollectOptions) error {
if opts.Print {
out := opts.Out
@@ -207,3 +208,19 @@ func emit(event schema.Event, opts CollectOptions) error {
_, err := writer.AppendEvent(event, writer.Options{Path: opts.LogPath, UserMode: opts.UserMode})
return err
}
+
+// advanceCursorPartial moves the cursor past source lines whose mapped events were all emitted, so
+// the next sweep retries from the source line that failed. One rollout line can map to several
+// events (a prompt and its session.handoff link); stopping at the last emitted event's line would
+// skip the rest of that line for good. failedIdx is the index into mapped of the event whose emit
+// failed. This is the claudesession rule.
+func advanceCursorPartial(cursor *Cursor, mapped []MappedEvent, failedIdx int) {
+ for i := failedIdx - 1; i >= 0; i-- {
+ if mapped[i].SourceLine != mapped[failedIdx].SourceLine {
+ if mapped[i].SourceLine > cursor.LastLine {
+ cursor.LastLine = mapped[i].SourceLine
+ }
+ return
+ }
+ }
+}
diff --git a/cli/beacon/internal/codexsession/partial_test.go b/cli/beacon/internal/codexsession/partial_test.go
new file mode 100644
index 00000000..88e9e6a6
--- /dev/null
+++ b/cli/beacon/internal/codexsession/partial_test.go
@@ -0,0 +1,67 @@
+package codexsession
+
+import (
+ "errors"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/schema"
+ "github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve"
+)
+
+func TestAdvanceCursorPartialNeverSkipsARecordsRemainingEvents(t *testing.T) {
+ // Lines 2 and 3 map to two events each: a prompt and its session.handoff link.
+ mapped := []MappedEvent{{SourceLine: 1}, {SourceLine: 2}, {SourceLine: 2}, {SourceLine: 3}, {SourceLine: 3}}
+ for _, tc := range []struct {
+ failed, start, want int
+ }{
+ {failed: 0, start: 0, want: 0}, // nothing written
+ {failed: 1, start: 0, want: 1}, // line 1 done, line 2 retried
+ {failed: 2, start: 0, want: 1}, // line 2's prompt written, its link failed: retry line 2
+ {failed: 3, start: 0, want: 2},
+ {failed: 4, start: 0, want: 2}, // line 3's prompt written, its link failed: retry line 3
+ {failed: 2, start: 5, want: 5}, // never moves the cursor backwards
+ } {
+ cursor := &Cursor{LastLine: tc.start}
+ advanceCursorPartial(cursor, mapped, tc.failed)
+ if cursor.LastLine != tc.want {
+ t.Fatalf("failure at %d from %d: LastLine = %d, want %d", tc.failed, tc.start, cursor.LastLine, tc.want)
+ }
+ }
+}
+
+// A sync whose session.handoff write fails after the prompt from the same rollout line was written
+// retries that line, so the link is not lost.
+func TestCollectOnceRetriesALineWhoseLinkFailedToWrite(t *testing.T) {
+ dir := t.TempDir()
+ codexDir := filepath.Join(dir, ".codex")
+ prompt := "Continue the work.\n\n" + asymptoteobserve.HandoffMarker("claude_code", "src-1")
+ writeFile(t, filepath.Join(codexDir, "sessions", "2026", "09", "25", "rollout-2026-09-25T09-00-00-new-1.jsonl"),
+ sessionMetaLine("new-1", "/tmp/repo")+"\n"+messageLine("user", "u1", prompt)+"\n")
+ opts := CollectOptions{CodexDir: codexDir, StatePath: filepath.Join(dir, "state.json"), LogPath: filepath.Join(dir, "runtime.jsonl"), Write: true, UserMode: true}
+
+ prev := emitEvent
+ t.Cleanup(func() { emitEvent = prev })
+ emitEvent = func(event schema.Event, opts CollectOptions) error {
+ if event.Event.Action == "session.handoff" {
+ return errors.New("disk full")
+ }
+ return prev(event, opts)
+ }
+ if _, err := CollectOnce(opts); err == nil {
+ t.Fatal("the failed link write must surface")
+ }
+ emitEvent = prev
+ if _, err := CollectOnce(opts); err != nil {
+ t.Fatalf("retry: %v", err)
+ }
+ data, err := os.ReadFile(opts.LogPath)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if n := strings.Count(string(data), `"session.handoff"`); n != 1 {
+ t.Fatalf("session.handoff events after the retry = %d, want 1:\n%s", n, data)
+ }
+}