test(schedule): close coverage gaps

packages/session/session-persistence/src/coordinator.ts

@@ -1143,7 +1143,7 @@ export class PersistenceCoordinator<TornMarker = unknown> {
       const seed = session.events.slice(0, live.seedEnd)
       await this.onCreated(session, seed)
     }).catch((error: unknown) => {
-      if (live.init === init) live.init = undefined
+      live.init = undefined
       throw error
     })
     live.init = init
@@ -1254,7 +1254,7 @@ export class PersistenceCoordinator<TornMarker = unknown> {
       if (tracked.materialized || tracked.cursor !== 0) {
         throw new Error(`session "${session.header.id}" lost its persisted artifact during live initialization`)
       }
-      if (seed.length > 0) await this.appendCore(session.header.id, seed)
+      await this.appendCore(session.header.id, seed)
       return
     }
     await this.adoptLivePrefix(session, seed, stored, tracked)

packages/session/session-persistence/tests/persistence.spec.ts

@@ -467,6 +467,87 @@ describe('PersistenceCoordinator retryable live initialization', () => {
     }
   })
 
+  it('retries a fork seed when initialization rejects before materialization', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    const backend = new ControlledBackend()
+    const appendGate = Promise.withResolvers<undefined>()
+    backend.beforeAppend = async (attempt) => {
+      if (attempt === 1) {
+        await appendGate.promise
+        throw new Error('pre-commit init write failure')
+      }
+    }
+    const fiber = await ctx.plugin(Object.assign((inner: Context) => {
+      new PersistenceCoordinator(inner, backend)
+    }, { inject: ['sessions'] }))
+
+    try {
+      const seed = oneTurnLog()
+      const session = ctx.sessions.create(SessionId('retry-unmaterialized-fork-seed'), {
+        seed,
+        meta: { cwd: '/w', seedLength: seed.length },
+      })
+      await vi.waitFor(() => { expect(backend.appendAttempts).toBe(1) })
+      const first = ctx.sessions.flush(session)
+      appendGate.resolve(undefined)
+      await expect(first).rejects.toThrow('pre-commit init write failure')
+      await expect(ctx.sessions.flush(session)).resolves.toBe(true)
+
+      expect(backend.appendAttempts).toBe(2)
+      expect(backend.store.get(session.id)?.events.map(event => event.seq))
+        .toEqual([0, 1, 2, 3, 4, 5, 6])
+    } finally {
+      appendGate.resolve(undefined)
+      await fiber.dispose()
+      await ctx.fiber.dispose()
+    }
+  })
+
+  it('rejects a retry when its adopted durable prefix disappears', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    const backend = new ControlledBackend()
+    const id = SessionId('retry-missing-adopted-prefix')
+    const seed = oneTurnLog()
+    const stored = seed.slice(0, 1)
+    const storedMeta = meta(id, '/w')
+    backend.store.set(id, { meta: storedMeta, events: structuredClone(stored) })
+    const appendGate = Promise.withResolvers<undefined>()
+    backend.beforeAppend = async (attempt) => {
+      if (attempt === 1) {
+        await appendGate.promise
+        throw new Error('pre-commit adoption write failure')
+      }
+    }
+    const fiber = await ctx.plugin(Object.assign((inner: Context) => {
+      new PersistenceCoordinator(inner, backend)
+    }, { inject: ['sessions'] }))
+
+    try {
+      const session = ctx.sessions.create(id, {
+        seed,
+        meta: { cwd: '/w', seedLength: seed.length },
+      })
+      await vi.waitFor(() => { expect(backend.appendAttempts).toBe(1) })
+      const first = ctx.sessions.flush(session)
+      appendGate.resolve(undefined)
+      await expect(first).rejects.toThrow('pre-commit adoption write failure')
+
+      backend.store.delete(id)
+      await expect(ctx.sessions.flush(session))
+        .rejects.toThrow('lost its persisted artifact during live initialization')
+      expect(backend.appendAttempts).toBe(1)
+    } finally {
+      appendGate.resolve(undefined)
+      if (!backend.store.has(id)) {
+        backend.store.set(id, { meta: storedMeta, events: structuredClone(stored) })
+      }
+      await fiber.dispose()
+      await ctx.fiber.dispose()
+    }
+  })
+
   it('retries only a missing suffix after stored-session adoption rejects', async () => {
     const ctx = new Context()
     await ctx.plugin(SessionStore)