refactor(redis): drop the clear-buffer script and the unused error class

A variadic DEL is already a single atomic command, so the Lua script and the
render function that built it achieved nothing a plain `del(events, seq, abort,
ownerBudget)` does not. The keys carry no hash tag either, so the script had the
same cluster-slot constraint it appeared to avoid.

Also deletes `RedisBudgetExceededError`, which was defined and never thrown, and
consolidates four rounds of stacked comments in the fold down to the one that
still describes the code.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: waleedlatif1

apps/realtime/src/handlers/file-doc-store.ts

@@ -853,7 +853,6 @@ export class FileDocStore {
         // appended snapshot id instead would silently drop those un-integrated peer entries.
         const upTo = room.lastId
         const snapshot = Buffer.from(Y.encodeStateAsUpdate(room.doc)).toString('base64')
-        // Captured with `upTo` so the two agree: exactly the entries this fold will trim.
         // Stamp the snapshot by what it folds: a real edit → SNAPSHOT_FIELD (a fresh catch-up treats it
         // as edited content, not a bare seed). An agent-ONLY stream (no real edit yet) → AGENT_FIELD, so a
         // peer catching up applies it as REDIS_AGENT_ORIGIN and never marks the doc edited — preserving
@@ -867,15 +866,9 @@ export class FileDocStore {
         // MINID keeps entries with id >= upTo: the snapshot, any un-integrated peer entries, and
         // `upTo` itself (redundant with the snapshot, harmless); it drops only the folded older deltas.
         await this.write.xTrim(streamKey(name), 'MINID', upTo)
-        // Never the snapshot's own size: a document whose snapshot already exceeds the ceiling
-        // would re-breach it the instant compaction finished and force a full snapshot append on
-        // every subsequent keystroke — the write amplification this threshold exists to prevent.
-        // Drop only what the trim provably removed. An entry published past `upTo` is retained by
-        // MINID and its bytes are still in Redis, so it stays counted; dropping it would disarm the
-        // trigger while the stream kept growing. Done after the trim, so a failed fold changes
-        // nothing and leaves the trigger armed.
-        // `MINID upTo` is inclusive — it keeps the entry whose id EQUALS `upTo`, so that entry's
-        // bytes are still in Redis and must stay counted. Keeps exactly what survived the trim.
+        // Drop exactly what the trim removed, which `MINID upTo` being INCLUSIVE makes `id < upTo`
+        // — the entry at the boundary survives, and its bytes are still in Redis. Run after the
+        // trim, so a failed fold leaves the ledger intact and the trigger armed.
         for (const id of room.pendingDeltas.keys()) {
           if (isAfterStreamId(upTo, id)) room.pendingDeltas.delete(id)
         }

apps/sim/lib/copilot/request/session/buffer.test.ts

@@ -66,29 +66,17 @@ const createRedisStub = () => {
     }),
     get: vi.fn().mockImplementation((key: string) => Promise.resolve(values.get(key) ?? null)),
     /**
-     * Stands in for both Lua scripts, dispatching on the leading `DEL` that only
-     * `CLEAR_BUFFER_SCRIPT` has. It reproduces their observable
+     * Stands in for `APPEND_EVENTS_SCRIPT`. It reproduces the script's observable
      * effects — dedupe, zadd, rank-trim, seq — so the read-path tests still exercise
      * real data, and exposes `budgetRefusal` so the refusal branch can be driven
      * without reimplementing the budget arithmetic here.
      */
     budgetRefusal: null as null | [number, string, number],
     eval: vi.fn().mockImplementation((...args: unknown[]) => {
-      const script = String(args[0])
       const numKeys = Number(args[1])
       const keys = args.slice(2, 2 + numKeys) as string[]
       const argv = args.slice(2 + numKeys) as Array<string | number>
 
-      // CLEAR_BUFFER_SCRIPT is the only one that opens with a DEL.
-      if (script.trimStart().startsWith("redis.call('DEL'")) {
-        for (const key of keys) {
-          values.delete(key)
-          sortedSets.delete(key)
-          counters.delete(key)
-        }
-        return Promise.resolve(1)
-      }
-
       if (api.budgetRefusal) return Promise.resolve(api.budgetRefusal)
 
       const [eventsKey, seqKey] = keys
@@ -419,17 +407,18 @@ describe('mothership-stream-outbox', () => {
     // its events stored with its reservation already erased.
     await clearBuffer('stream-1')
 
-    const evalCall = mockRedis.eval.mock.calls.at(-1)
-    expect(evalCall?.[1]).toBe(4)
-    expect(evalCall?.[5]).toBe('execution:redis-budget:copilot_stream:stream-1')
+    // One variadic DEL: a single atomic command, so no script is needed for the counter to go
+    // with the data it accounts for.
+    expect(mockRedis.del).toHaveBeenCalledTimes(1)
+    expect(mockRedis.del.mock.calls[0]).toContain('execution:redis-budget:copilot_stream:stream-1')
   })
 
   it('never touches the shared user counter when clearing a buffer', async () => {
     // An owner id is not proof of who wrote the bytes, so crediting the user counter here would
     // let anyone who can name a stream decrement a ceiling they never charged.
     await clearBuffer('stream-1')
 
-    const keys = mockRedis.eval.mock.calls.at(-1)?.slice(2, 6) as string[]
+    const keys = mockRedis.del.mock.calls[0] as string[]
     expect(keys.some((key) => key.includes('redis-budget:user:'))).toBe(false)
   })
 })

apps/sim/lib/copilot/request/session/buffer.ts

@@ -10,7 +10,6 @@ import {
   parseRedisBudgetRefusal,
   type RedisBudgetRefusal,
   renderRedisBudgetLua,
-  renderRedisBudgetReleaseLua,
 } from '@/lib/core/redis/byte-budget.server'
 import {
   type PersistedStreamEventEnvelope,
@@ -103,32 +102,27 @@ export async function allocateCursor(streamId: string): Promise<{
   return { seq, cursor: String(seq) }
 }
 
-/** Deletes a stream's buffer and releases its reservation together. KEYS: [events, seq, abort, budget...]. */
-const CLEAR_BUFFER_SCRIPT = `
-redis.call('DEL', KEYS[1], KEYS[2], KEYS[3])
-${renderRedisBudgetReleaseLua(3)}
-return 1
-`
-
 export async function resetBuffer(streamId: string): Promise<void> {
   await clearBuffer(streamId, 'reset_outbox')
 }
 
 export async function clearBuffer(streamId: string, operation = 'clear_outbox'): Promise<void> {
   /*
-    Delete and release in ONE script. The counter outlives the data it accounts for unless
-    it is dropped here — these keys are deleted rather than expired, so a retry reusing the
-    same streamId would be refused against bytes that no longer exist. Doing it in a second
-    round trip would be its own hole: a concurrent append landing between the two would keep
-    its events stored with its reservation already erased.
-
-    Only the owner counter, never the shared user counter — see the release fragment.
+    The owner counter is deleted WITH the data it accounts for. These keys are deleted rather
+    than expired, so a counter left behind would refuse a retry reusing the same streamId
+    against bytes that no longer exist; dropping it in a second round trip would be its own
+    hole, since a concurrent append landing between the two would keep its events stored with
+    its reservation already erased. One variadic DEL is a single atomic command, so no script
+    is needed to get that.
+
+    The shared user counter is deliberately untouched: an owner id is not proof of who wrote
+    the bytes, so crediting it here would let anyone able to name a stream decrement a ceiling
+    they never charged — and a counter driven down grants writes rather than denying them. Its
+    fixed window settles it instead, over-counting in the safe direction meanwhile.
   */
   const [ownerBudgetKey] = getRedisBudgetKeys({ kind: 'copilot_stream', id: streamId })
   await withRedisRetry({ operation, streamId }, async (redis) => {
-    await redis.eval(
-      CLEAR_BUFFER_SCRIPT,
-      4,
+    await redis.del(
       getEventsKey(streamId),
       getSeqKey(streamId),
       getAbortKey(streamId),

apps/sim/lib/core/redis/byte-budget.server.ts

@@ -115,24 +115,6 @@ export interface RedisBudgetRefusal {
   attemptedBytes: number
 }
 
-export class RedisBudgetExceededError extends Error {
-  readonly resource: RedisBudgetRefusal['resource']
-  readonly currentBytes: number
-  readonly limitBytes: number
-  readonly attemptedBytes: number
-
-  constructor(refusal: RedisBudgetRefusal) {
-    super(
-      `Redis byte budget exceeded (${refusal.resource}): ${refusal.attemptedBytes} bytes would take ${refusal.currentBytes} past ${refusal.limitBytes}`
-    )
-    this.name = 'RedisBudgetExceededError'
-    this.resource = refusal.resource
-    this.currentBytes = refusal.currentBytes
-    this.limitBytes = refusal.limitBytes
-    this.attemptedBytes = refusal.attemptedBytes
-  }
-}
-
 /**
  * Lua that reserves or releases `net_bytes` against the caller's budget keys.
  *
@@ -201,31 +183,6 @@ end
 `
 }
 
-/**
- * Lua that drops an owner's counter, for data that is deleted rather than left to expire.
- *
- * Rendered into the caller's own script, the same way {@link renderRedisBudgetLua} is, so
- * the release commits together with the delete it accounts for. Releasing in a second
- * round trip would let a concurrent write land in between and keep its bytes stored with
- * its reservation already erased.
- *
- * The shared user counter is deliberately NOT credited here. An owner id is not proof of
- * who wrote the bytes — anyone who can name an owner could otherwise decrement a counter
- * they never charged, which is the one direction that must never be possible, since a
- * counter driven down grants writes rather than denying them. The user counter's fixed
- * window is what settles it instead: it already tolerates accruing bytes Redis has dropped
- * (see {@link REDIS_BUDGET_TTL_SECONDS}), and this is the same over-count, bounded by the
- * same window.
- *
- * Contract: the owner key is the **last** entry of `KEYS`, and `baseKeyCount` is how many
- * precede it.
- */
-export function renderRedisBudgetReleaseLua(baseKeyCount: number): string {
-  return `
-redis.call('DEL', KEYS[${baseKeyCount + 1}])
-`
-}
-
 /** Parses the `{0, resource, current}` refusal a guarded script returns. */
 export function parseRedisBudgetRefusal(
   result: unknown,