} else if (budgetChars > CONTEXT_TRUNCATION_BUFFER) {
            // Fallback: truncate the newest message to fit
            final LlmMessage newest = history.get(history.size() - 1);
            final String truncated = newest.getContent().substring(0, Math.min(budgetChars, newest.getContent().length()));
            request.addMessage(new LlmMessage(newest.getRole(), truncated));
            if (logger.isDebugEnabled()) {

        for (int i = 0; i < 1100; i++) {
            helper.offer(new LogNotificationEvent(i, "ERROR", "org.test", "msg" + i, null));
        }
        List<LogNotificationEvent> events = helper.drainAll();
        // The newest events should be retained; oldest dropped
        // Last event should be msg1099
        LogNotificationEvent last = events.get(events.size() - 1);
        assertEquals("msg1099", last.getMessage());
    }

        Thread.sleep(100);
        try (FileWriter writer = new FileWriter(lmhostsFile)) {
            writer.write("192.168.1.200 NEWHOST\n");
        }

        // Should reload file and find new host
        result = lmhosts.getByName("NEWHOST", mockContext);
        assertNotNull(result);

        // Old host should not be found
        result = lmhosts.getByName("TESTHOST", mockContext);

    }

    @Test
    @Disabled
    void testResolveCorrectDependenciesWhenDifferentDependenciesOnNewest()
            throws ArtifactResolutionException, InvalidVersionSpecificationException {
        // TODO use newest conflict resolver
        ArtifactSpec a = createArtifactSpec("a", "1.0");
        ArtifactSpec b = a.addDependency("b", "1.0");
        ArtifactSpec c2 = b.addDependency("c", "2.0");

        final LlmChatRequest request = new LlmChatRequest();
        client.testAddIntentHistory(request, history);
        // Default: maxMessages=6, maxChars=3000
        // From newest: A2(2), Q2(2+2=4), assistant(500+4=504), Short(5+504=509) => all fit
        assertEquals(4, request.getMessages().size());
    }

    @Test
    public void test_addIntentHistory_maxMessages() {

		// In distributed setup, anonymized addr = 'poolNum.serverNum'
		newHost := fmt.Sprintf("pool%d.server%d", poolNum, srvrNum)
		schemePfx := endpoint.Scheme + "://"

		// Hostname
		mapIfNotPresent(hostAnonymizer, endpoint.Hostname(), newHost)

		newHostPort := newHost
		if len(endpoint.Port()) > 0 {
			// Host + port
			newHostPort = newHost + ":" + endpoint.Port()

		t.Fatalf("value differs from expected")
	}
	if lc.Len() != 1 {
		t.Fatalf("length differs from expected")
	}
}

func getRand(tb testing.TB) int64 {
	out, err := rand.Int(rand.Reader, big.NewInt(math.MaxInt64))
	if err != nil {
		tb.Fatal(err)
	}
	return out.Int64()

	}
	return versions, buf, nil
}

// decodeVersions will decode a number of versions from a buffer
// and perform a callback for each version in order, newest first.
// Any non-nil error is returned.
func decodeVersions(buf []byte, versions int, fn func(idx int, hdr, meta []byte) error) (e error) {
	var tHdr, tMeta []byte // Zero copy bytes
	for i := 0; i < versions; i++ {

// sortsBefore can be used as a tiebreaker for stable sorting/selecting.
// Returns false on ties.
func (x xlMetaV2VersionHeader) sortsBefore(o xlMetaV2VersionHeader) bool {
	if x == o {
		return false
	}
	// Prefer newest modtime.
	if x.ModTime != o.ModTime {
		return x.ModTime > o.ModTime
	}

	// The following doesn't make too much sense, but we want sort to be consistent nonetheless.
	// Prefer lower types

	}
	return x, buf, nil
}

// decodeVersions will decode a number of versions from a buffer
// and perform a callback for each version in order, newest first.
// Any non-nil error is returned.
func decodeVersions(buf []byte, versions int, fn func(idx int, hdr, meta []byte) error) (err error) {
	var tHdr, tMeta []byte // Zero copy bytes
	for i := range versions {