merge feat/layered-cache: the delta seam's sections 1-5, and what the live scripts found

Sections 1 through 5 of plans/delta-seam-rebased.md, plus the defects that
surfaced while proving them.

  THE SEND PATH   the request body is written as it is sent (default on,
                  board-configurable per aria), byte-identical to what it
                  replaced. 1,448,136 B -> 663 B per send at 10,000 messages.
  THE STUDY FIX   a translator cursor advances only when a ROW IS WRITTEN, so
                  a delta spans every untranslated message between. Gluck's
                  own example is the test.
  COALESCING      adjacent same-role rows merge AT ASSEMBLY; the log stays
                  append-only.
  A REGRESSION    every send on a new aria failed 'empty context' -- a
                  translator span cut by another channel's fork base.
  RETENTION       the in-flight assembly is released when its turn ends.

And the instruments: a citation checker, a read-path lock survey, and four
live scripts that now assert the sends they depend on -- three of them had
been printing PASS while discarding them.

Author: gluck

internal/angelus/drain_test.go

@@ -65,7 +65,7 @@ func TestShutdownDrainSealsPartialTurn(t *testing.T) {
 	a.Shutdown(2 * time.Second)
 	assert.Less(t, time.Since(start), 5*time.Second)
 
-	ir, err := backend.Open(conv)
+	ir, err := backend.OpenFigIR(conv)
 	require.NoError(t, err)
 	tail, ok := ir.PeekTail()
 	require.True(t, ok)
@@ -91,7 +91,7 @@ model = "mock-model"
 	require.NoError(t, err)
 	conv, err := backend.CreateConversation(outfit)
 	require.NoError(t, err)
-	ir, err := backend.Open(conv)
+	ir, err := backend.OpenFigIR(conv)
 	require.NoError(t, err)
 	_, err = ir.Append(store.Entry[message.Message]{Payload: message.Message{
 		Role: message.RoleInput, Content: []message.Content{message.TextContent("run it")},

internal/angelus/fork_live_test.go

@@ -48,7 +48,7 @@ type liveForkBackend struct {
 
 // Open backs forkPointOf, which maps a turn id to a fork LT. The log holds one
 // completed exchange so turn 1 resolves.
-func (f *liveForkBackend) Open(string) (store.Log[message.Message], error) {
+func (f *liveForkBackend) OpenFigIR(string) (store.Log[message.Message], error) {
 	if f.log == nil {
 		l := store.NewMemLog[message.Message]()
 		l.Append(store.Entry[message.Message]{Payload: message.Message{Role: message.RoleInput, TurnID: 1}})
@@ -191,11 +191,6 @@ func (p *activeForkProvider) Send(ctx context.Context, in provider.SendInput, bu
 		Content:    []message.Content{message.TextContent("complete")},
 		StopReason: message.StopEnd,
 	}
-	entry, err := in.FigLog.Append(store.Entry[message.Message]{Payload: msg})
-	if err != nil {
-		return err
-	}
-	msg.LogicalTime = entry.LT
 	bus.PushMessageEnd(string(msg.StopReason))
 	bus.PushFigaro(msg)
 	return nil
@@ -272,12 +267,12 @@ func TestForkDuringActiveStreamKeepsContinuationRunning(t *testing.T) {
 	default:
 	}
 
-	alternative, err := backend.Open(response.Alternative)
+	alternative, err := backend.OpenFigIR(response.Alternative)
 	require.NoError(t, err)
 	require.Equal(t, 1, message.CountMessages(unwrapMessages(alternative.Read())))
 
 	release()
-	continuation, err := backend.Open(id)
+	continuation, err := backend.OpenFigIR(id)
 	require.NoError(t, err)
 	require.Eventually(t, func() bool {
 		return agent.Info().State == "idle" && message.CountMessages(unwrapMessages(continuation.Read())) == 2
@@ -333,11 +328,6 @@ func (p *activeToolProvider) Send(_ context.Context, in provider.SendInput, bus
 			StopReason: message.StopEnd,
 		}
 	}
-	entry, err := in.FigLog.Append(store.Entry[message.Message]{Payload: msg})
-	if err != nil {
-		return err
-	}
-	msg.LogicalTime = entry.LT
 	bus.PushMessageEnd(string(msg.StopReason))
 	bus.PushFigaro(msg)
 	return nil
@@ -439,13 +429,13 @@ func TestForkDuringActiveToolKeepsToolAndContinuationRunning(t *testing.T) {
 	default:
 	}
 
-	alternative, err := backend.Open(response.Alternative)
+	alternative, err := backend.OpenFigIR(response.Alternative)
 	require.NoError(t, err)
 	alternativeCount := message.CountMessages(unwrapMessages(alternative.Read()))
 	require.GreaterOrEqual(t, alternativeCount, 1)
 
 	release()
-	continuation, err := backend.Open(id)
+	continuation, err := backend.OpenFigIR(id)
 	require.NoError(t, err)
 	require.Eventually(t, func() bool {
 		return agent.Info().State == "idle" && message.CountMessages(unwrapMessages(continuation.Read())) == 4

internal/angelus/gc_test.go

@@ -110,7 +110,7 @@ func TestGCLeavesLiveAriasReadable(t *testing.T) {
 	if got := runGCHandler(t, h, false); got.Collected != 1 {
 		t.Fatalf("collected %d, want 1", got.Collected)
 	}
-	if _, err := backend.Open(conv); err != nil {
+	if _, err := backend.OpenFigIR(conv); err != nil {
 		t.Fatalf("live aria unreadable after gc: %v", err)
 	}
 }

internal/angelus/import_test.go

@@ -64,7 +64,7 @@ func TestImportLandsAsAWholeConversation(t *testing.T) {
 	require.Equal(t, "23a5a06d", resp.WasID)
 	require.Equal(t, len(msgs), resp.Messages)
 
-	log, err := backend.Open(resp.FigaroID)
+	log, err := backend.OpenFigIR(resp.FigaroID)
 	require.NoError(t, err)
 	var got []string
 	for _, e := range log.Read() {
@@ -124,7 +124,7 @@ func TestImportLeavesExistingAriasAlone(t *testing.T) {
 	require.NoError(t, err)
 	resident, err := backend.CreateConversation(outfit)
 	require.NoError(t, err)
-	rlog, err := backend.Open(resident)
+	rlog, err := backend.OpenFigIR(resident)
 	require.NoError(t, err)
 	_, err = rlog.Append(store.Entry[message.Message]{Payload: say(message.RoleOutput, "I was here first")})
 	require.NoError(t, err)
@@ -135,7 +135,7 @@ func TestImportLeavesExistingAriasAlone(t *testing.T) {
 	})
 	require.NotEqual(t, resident, imported.FigaroID)
 
-	after, err := backend.Open(resident)
+	after, err := backend.OpenFigIR(resident)
 	require.NoError(t, err)
 	require.Len(t, after.Read(), before, "the resident aria must be untouched")
 	var texts []string

internal/angelus/integration_test.go

@@ -37,11 +37,6 @@ func (m *mockProviderForIntegration) Send(_ context.Context, in provider.SendInp
 		Content:    []message.Content{message.TextContent("42")},
 		StopReason: message.StopEnd,
 	}
-	entry, err := in.FigLog.Append(store.Entry[message.Message]{Payload: msg})
-	if err != nil {
-		return err
-	}
-	msg.LogicalTime = entry.LT
 	bus.PushMessageEnd(string(msg.StopReason))
 	bus.PushFigaro(msg)
 	return nil

internal/angelus/listen_survives_interrupt_test.go

@@ -59,11 +59,6 @@ func (p *switchProvider) Send(ctx context.Context, in provider.SendInput, bus pr
 		Content:    []message.Content{message.TextContent(p.fastText)},
 		StopReason: message.StopEnd,
 	}
-	e, err := in.FigLog.Append(store.Entry[message.Message]{Payload: msg})
-	if err != nil {
-		return err
-	}
-	msg.LogicalTime = e.LT
 	bus.PushFigaro(msg)
 	return nil
 }

internal/angelus/protocol.go

@@ -661,7 +661,7 @@ func (h *handlers) checkForkLT(ariaID string, lt uint64) error {
 	if lt == 0 {
 		return nil
 	}
-	log, err := h.angelus.Backend.Open(ariaID)
+	log, err := h.angelus.Backend.OpenFigIR(ariaID)
 	if err != nil {
 		return fmt.Errorf("fork: open %s: %w", ariaID, err)
 	}
@@ -680,7 +680,7 @@ func (h *handlers) forkPointOf(ariaID string, turn uint64) (uint64, error) {
 	if turn == 0 {
 		return 0, nil // head fork
 	}
-	log, err := h.angelus.Backend.Open(ariaID)
+	log, err := h.angelus.Backend.OpenFigIR(ariaID)
 	if err != nil {
 		return 0, fmt.Errorf("fork: open %s: %w", ariaID, err)
 	}
@@ -981,7 +981,7 @@ func (h *handlers) importAria(ctx context.Context, params json.RawMessage) (inte
 	if err != nil {
 		return nil, fmt.Errorf("import: create conversation: %w", err)
 	}
-	log, err := h.angelus.Backend.Open(id)
+	log, err := h.angelus.Backend.OpenFigIR(id)
 	if err != nil {
 		return nil, fmt.Errorf("import: open %q: %w", id, err)
 	}
@@ -1735,7 +1735,7 @@ func (h *handlers) ariaRead(ctx context.Context, params json.RawMessage) (interf
 
 	// The backend returns the same shared, memoized IR instance the live
 	// agent holds, so reads run lock-free against its writes.
-	log, err := h.angelus.Backend.Open(req.FigaroID)
+	log, err := h.angelus.Backend.OpenFigIR(req.FigaroID)
 	if err != nil {
 		return nil, fmt.Errorf("aria.read: open: %w", err)
 	}

internal/angelus/protocol_bench_test.go

@@ -28,7 +28,7 @@ type readBenchBackend struct {
 	log store.Log[message.Message]
 }
 
-func (b readBenchBackend) Open(string) (store.Log[message.Message], error) {
+func (b readBenchBackend) OpenFigIR(string) (store.Log[message.Message], error) {
 	return b.log, nil
 }
 
@@ -109,7 +109,7 @@ func BenchmarkDormantList(b *testing.B) {
 					}}); err != nil {
 						b.Fatal(err)
 					}
-					log, err := backend.Open(id)
+					log, err := backend.OpenFigIR(id)
 					if err != nil {
 						b.Fatal(err)
 					}

internal/angelus/protocol_list_test.go

@@ -54,7 +54,7 @@ func (b *metadataListBackend) FormState(string) (form.Snapshot, error) {
 	return form.Snapshot{}, nil
 }
 
-func (b *metadataListBackend) Open(string) (store.Log[message.Message], error) {
+func (b *metadataListBackend) OpenFigIR(string) (store.Log[message.Message], error) {
 	b.logReads.Add(1)
 	return store.NewMemLog[message.Message](), nil
 }

internal/angelus/provider_switch_test.go

@@ -38,11 +38,6 @@ func (m *namedMockProvider) Send(_ context.Context, in provider.SendInput, bus p
 		Content:    []message.Content{message.TextContent("served by " + m.name)},
 		StopReason: message.StopEnd,
 	}
-	entry, err := in.FigLog.Append(store.Entry[message.Message]{Payload: msg})
-	if err != nil {
-		return err
-	}
-	msg.LogicalTime = entry.LT
 	bus.PushMessageEnd(string(msg.StopReason))
 	bus.PushFigaro(msg)
 	return nil