Skip to content

graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs

Python
29.1 KB
Raw Blame
//! White-box tests for agent_server_compact.zig, parked here under the
//! 600-line ceiling (same pattern as router_catalog_tests.zig).

const std = @import("std");
const Io = std.Io;
const Value = std.json.Value;
const main_mod = @import("main.zig");
const Agent = @import("agent.zig").Agent;
const Provider = @import("provider.zig").Provider;
const provider = @import("provider.zig");
const asc = @import("agent_server_compact.zig");
const enabled = asc.enabled;
const noteExposure = asc.noteExposure;
const noteClientSummary = asc.noteClientSummary;
const writeContextManagement = asc.writeContextManagement;
const writeContextManagementBody = asc.writeContextManagementBody;
const manualRoute = asc.manualRoute;
const manualServerEligible = asc.manualServerEligible;
const compactEndpoint = asc.compactEndpoint;
const compactBody = asc.compactBody;
const installCompactedOutput = asc.installCompactedOutput;
const installInStreamCompaction = asc.installInStreamCompaction;
const manualCompact = asc.manualCompact;
const pruneToLatestBlob = asc.pruneToLatestBlob;
const pruneIf = asc.pruneIf;
const autocompact = asc.autocompact;
const autocompactIf = asc.autocompactIf;
const explicitCompact = asc.explicitCompact;
const installCompactionItem = asc.installCompactionItem;
const ManualRoute = asc.ManualRoute;
const test_support = @import("agent_compact_test_support.zig");

fn testAgent(a: std.mem.Allocator, kind: Provider.Kind) Agent {
    var agent = test_support.subAgent(a, false);
    agent.provider.kind = kind;
    agent.gpa = a;
    agent.out = null;
    agent.label = "t";
    agent.goal_note_fp = 0;
    agent.history_rewrites = 0;
    agent.messages = std.json.Array.init(a);
    agent.compaction_window = .{};
    agent.call_kind = .root;
    agent.stream_quiet = true;
    return agent;
}

fn item(a: std.mem.Allocator, typ: []const u8, call_id: ?[]const u8) !std.json.Value {
    var obj: std.json.ObjectMap = .empty;
    try obj.put(a, "type", .{ .string = typ });
    if (call_id) |c| try obj.put(a, "call_id", .{ .string = c });
    return .{ .object = obj };
}

test "manual server compaction routes direct OpenAI, Codegraff, and Codex" {
    var p: Provider = .{ .id = "openai", .kind = .responses, .auth = .bearer, .url = "https://api.openai.com/v1/responses", .api_key = "k", .model = "m", .context = 272_000 };
    try std.testing.expectEqual(ManualRoute.standalone, manualRoute(p));
    p.id = "codegraff";
    p.url = "https://gateway.codegraff.com/v1/responses";
    p.model = "gpt-6-astra";
    try std.testing.expectEqual(ManualRoute.standalone, manualRoute(p));
    try std.testing.expect(manualServerEligible(p));
    p.model = "gpt-5.6-sol";
    try std.testing.expectEqual(ManualRoute.standalone, manualRoute(p));
    p.model = "grok-4.6";
    try std.testing.expectEqual(ManualRoute.local, manualRoute(p));
    try std.testing.expect(!manualServerEligible(p));
    p.id = "xai";
    p.model = "grok-4.6";
    try std.testing.expectEqual(ManualRoute.local, manualRoute(p));
    try std.testing.expect(!manualServerEligible(p));
    try std.testing.expect(p.serverCompactUrl() == null);
    p.id = "codex";
    try std.testing.expectEqual(ManualRoute.in_stream, manualRoute(p));
    try std.testing.expect(manualServerEligible(p));
    p.id = "openai-compatible-router";
    try std.testing.expectEqual(ManualRoute.local, manualRoute(p));
    p.id = "openai";
    p.kind = .openai;
    try std.testing.expect(!manualServerEligible(p));
    p.kind = .anthropic;
    try std.testing.expect(!manualServerEligible(p));
}

test "manual compact endpoint appends compact and rejects non-Responses URLs" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    try std.testing.expectEqualStrings("http://127.0.0.1:8765/responses/compact", try compactEndpoint(a, "http://127.0.0.1:8765/responses"));
    try std.testing.expectError(error.UnsupportedServerCompaction, compactEndpoint(a, "http://127.0.0.1:8765/chat/completions"));
}

test "manual compact body sends model, canonical Responses input, and instructions" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    agent.provider.model = "gpt-test";
    agent.sys_normal = "system-test";
    try agent.messages.append(try item(a, "message", null));
    const body = try compactBody(&agent);
    defer a.free(body);
    const parsed = try std.json.parseFromSliceLeaky(std.json.Value, a, body, .{});
    try std.testing.expectEqualStrings("gpt-test", parsed.object.get("model").?.string);
    try std.testing.expectEqualStrings("system-test", parsed.object.get("instructions").?.string);
    try std.testing.expectEqual(@as(usize, 1), parsed.object.get("input").?.array.items.len);
}

test "installCompactedOutput transactionally replaces history and resets meters" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    try agent.messages.append(try item(a, "message", null));
    agent.last_context_tokens = 99;
    agent.context_local_tokens = 88;
    agent.goal_note_fp = 77;
    const invalid = std.json.Value{ .object = .empty };
    try std.testing.expectError(error.InvalidCompactionResponse, installCompactedOutput(&agent, invalid));
    try std.testing.expectError(error.InvalidCompactionResponse, installInStreamCompaction(&agent, .empty));
    try std.testing.expectEqual(@as(usize, 1), agent.messages.items.len);

    var output = std.json.Array.init(a);
    try output.append(try item(a, "message", null));
    var obj: std.json.ObjectMap = .empty;
    try obj.put(a, "output", .{ .array = output });
    try std.testing.expectError(error.MissingCompactionItem, installInStreamCompaction(&agent, obj));
    try std.testing.expectEqual(@as(usize, 1), agent.messages.items.len);
    try output.append(try item(a, "compaction", null));
    try output.append(try item(a, "message", null));
    try obj.put(a, "output", .{ .array = output });
    try std.testing.expectEqual(@as(usize, 3), try installCompactedOutput(&agent, .{ .object = obj }));
    try std.testing.expectEqual(@as(usize, 3), agent.messages.items.len);
    try std.testing.expectEqual(@as(usize, 1), try installInStreamCompaction(&agent, obj));
    try std.testing.expectEqual(@as(usize, 1), agent.messages.items.len);
    try std.testing.expectEqualStrings("compaction", agent.messages.items[0].object.get("type").?.string);
    try std.testing.expectEqual(@as(u64, 0), agent.last_context_tokens);
    try std.testing.expectEqual(@as(u64, 0), agent.context_local_tokens);
    try std.testing.expectEqual(@as(u64, 0), agent.goal_note_fp);
    try std.testing.expectEqual(@as(u64, 2), agent.history_rewrites);
}

test "enabled: responses-only; server is the default; override wins" {
    var p: Provider = .{ .id = "codex", .kind = .responses, .auth = .bearer, .url = "", .api_key = "k", .model = "m", .context = 272_000 };
    try std.testing.expect(enabled(p)); // server arm by default
    p.kind = .anthropic;
    try std.testing.expect(!enabled(p));
    p.kind = .openai;
    try std.testing.expect(!enabled(p));
    p.kind = .responses;
    p.id = "openai";
    try std.testing.expect(enabled(p));
    p.id = "kilo"; // third-party Responses hosts keep the local summary
    try std.testing.expect(!enabled(p));
    p.id = "xai";
    try std.testing.expect(!enabled(p)); // client summarizer, not xAI blob
    p.id = "codegraff";
    p.model = "gpt-6-astra";
    try std.testing.expect(enabled(p)); // GPT-5.6+ on the gateway uses /responses/compact
    p.kind = .openai;
    try std.testing.expect(!enabled(p));
    p.kind = .responses;
    p.id = "codex";
    asc.g_server_compact_override = false;
    try std.testing.expect(!enabled(p));
    asc.g_server_compact_override = true;
    try std.testing.expect(enabled(p));
    asc.g_server_compact_override = null;
}

test "writeContextManagement: automatic threshold and forced Codex pass stay OpenAI-only" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    var aw: @import("std").Io.Writer.Allocating = .init(a);
    var s: std.json.Stringify = .{ .writer = &aw.writer };
    try s.beginObject();
    try writeContextManagementBody(&s, 80_000);
    try s.endObject();
    try std.testing.expect(std.mem.indexOf(u8, aw.written(), "\"compact_threshold\":80000") != null);
    agent.provider.id = "codex";
    agent.server_compaction_request = true;
    var aw2: @import("std").Io.Writer.Allocating = .init(a);
    var s2: std.json.Stringify = .{ .writer = &aw2.writer };
    try s2.beginObject();
    try writeContextManagement(&agent, &s2);
    try s2.endObject();
    try std.testing.expect(std.mem.indexOf(u8, aw2.written(), "\"compact_threshold\":1000") != null);
    agent.provider.id = "openai-compatible-router";
    var aw3: @import("std").Io.Writer.Allocating = .init(a);
    var s3: std.json.Stringify = .{ .writer = &aw3.writer };
    try s3.beginObject();
    try writeContextManagement(&agent, &s3);
    try s3.endObject();
    try std.testing.expectEqualStrings("{}", aw3.written());
}

test "pruneToLatestBlob: no blob or blob-first leaves history untouched" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    try agent.messages.append(try item(a, "message", null));
    try std.testing.expect(!pruneIf(&agent, true));
    try std.testing.expectEqual(@as(usize, 1), agent.messages.items.len);
    // blob already at the head: nothing to prune
    var agent2 = testAgent(a, .responses);
    try agent2.messages.append(try item(a, "compaction", null));
    try agent2.messages.append(try item(a, "message", null));
    try std.testing.expect(!pruneIf(&agent2, true));
    try std.testing.expectEqual(@as(usize, 2), agent2.messages.items.len);
    try std.testing.expectEqual(@as(u32, 0), agent2.history_rewrites);
}

test "pruneToLatestBlob: prunes to the newest blob and resets the meters" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    try agent.messages.append(try item(a, "message", null)); // pruned
    try agent.messages.append(try item(a, "compaction", null)); // older blob — superseded
    try agent.messages.append(try item(a, "message", null)); // pruned
    try agent.messages.append(try item(a, "compaction", null)); // newest blob
    try agent.messages.append(try item(a, "function_call", "c1")); // pair survives intact
    try agent.messages.append(try item(a, "function_call_output", "c1"));
    agent.last_context_tokens = 200_000;
    agent.context_local_tokens = 190_000;
    try std.testing.expect(pruneIf(&agent, true));
    try std.testing.expectEqual(@as(usize, 3), agent.messages.items.len);
    try std.testing.expectEqualStrings("compaction", agent.messages.items[0].object.get("type").?.string);
    try std.testing.expectEqual(@as(u32, 1), agent.history_rewrites);
    try std.testing.expectEqual(@as(u64, 0), agent.last_context_tokens);
    try std.testing.expectEqual(@as(u64, 0), agent.context_local_tokens);
}

fn imageUser(a: std.mem.Allocator) !Value {
    var image: std.json.ObjectMap = .empty;
    try image.put(a, "type", .{ .string = "image_url" });
    var image_url: std.json.ObjectMap = .empty;
    try image_url.put(a, "url", .{ .string = "data:image/png;base64,AAA" });
    try image.put(a, "image_url", .{ .object = image_url });
    var content = std.json.Array.init(a);
    var tb: std.json.ObjectMap = .empty;
    try tb.put(a, "type", .{ .string = "text" });
    try tb.put(a, "text", .{ .string = "read this" });
    try content.append(.{ .object = tb });
    try content.append(.{ .object = image });
    var user: std.json.ObjectMap = .empty;
    try user.put(a, "role", .{ .string = "user" });
    try user.put(a, "content", .{ .array = content });
    return .{ .object = user };
}

test "pruneIf: refuses a blob that would drop an unresolved image prompt (#581)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    try agent.messages.append(try item(a, "message", null));
    try agent.messages.append(try imageUser(a)); // live pin
    try agent.messages.append(try item(a, "function_call", "c1"));
    try agent.messages.append(try item(a, "function_call_output", "c1"));
    try agent.messages.append(try item(a, "compaction", null)); // after the pin
    try std.testing.expect(!pruneIf(&agent, true));
    try std.testing.expectEqual(@as(usize, 5), agent.messages.items.len);
    try std.testing.expectEqual(@as(u32, 0), agent.history_rewrites);
}

test "pruneIf: a blob before the live image pin still prunes the prefix (#581)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    try agent.messages.append(try item(a, "message", null));
    try agent.messages.append(try item(a, "compaction", null));
    try agent.messages.append(try imageUser(a));
    try std.testing.expect(pruneIf(&agent, true));
    try std.testing.expectEqual(@as(usize, 2), agent.messages.items.len);
    try std.testing.expectEqualStrings("compaction", agent.messages.items[0].object.get("type").?.string);
}

test "explicitCompact: refuses to fold an unresolved image prompt into a blob (#581)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    agent.arena = a;
    agent.provider.id = "xai";
    try agent.messages.append(try imageUser(a));
    try agent.messages.append(try item(a, "function_call", "c1"));
    try agent.messages.append(try item(a, "function_call_output", "c1"));
    try std.testing.expect(!explicitCompact(&agent));
    try std.testing.expectEqual(@as(usize, 3), agent.messages.items.len);
    try std.testing.expectEqual(@as(u32, 0), agent.history_rewrites);
}

test "pruneToLatestBlob: an orphaned tool output refuses the prune" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    try agent.messages.append(try item(a, "function_call", "c1")); // pruned by the cut
    try agent.messages.append(try item(a, "compaction", null));
    try agent.messages.append(try item(a, "function_call_output", "c1")); // orphan if pruned
    try std.testing.expect(!pruneIf(&agent, true));
    try std.testing.expectEqual(@as(usize, 3), agent.messages.items.len);
}

test "pruneIf: never fires off the server arm or off responses" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .anthropic);
    try agent.messages.append(try item(a, "message", null));
    try agent.messages.append(try item(a, "compaction", null));
    try std.testing.expect(!pruneIf(&agent, true));
    try std.testing.expectEqual(@as(usize, 2), agent.messages.items.len);
}

test "autocompact: responses providers hold at the ordinary threshold without a blob" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses); // context 100_000
    try agent.messages.append(try item(a, "message", null));
    // Over the 80% compactAt line but under the 95% wall, no blob: the server
    // owns compaction now, so history must survive untouched (legacy policy
    // would have run a summary here).
    autocompactIf(&agent, 85_000, true);
    try std.testing.expectEqual(@as(usize, 1), agent.messages.items.len);
    try std.testing.expectEqual(@as(u32, 0), agent.history_rewrites);
}

test "installCompactionItem restarts history from the blob and resets the meters (#502)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    agent.arena = a;
    try agent.messages.append(try item(a, "message", null));
    try agent.messages.append(try item(a, "function_call", "c1"));
    try agent.messages.append(try item(a, "function_call_output", "c1"));
    agent.last_context_tokens = 400_000;
    const resp =
        \\{"id":"cmp_1","object":"response.compaction","output":[{"type":"compaction","id":"cmp_1","encrypted_content":"BLOB"}],
        \\ "usage":{"input_tokens":9000,"output_tokens":400,"dropped_message_count":3}}
    ;
    try std.testing.expect(installCompactionItem(&agent, resp));
    try std.testing.expectEqual(@as(usize, 1), agent.messages.items.len);
    try std.testing.expectEqualStrings("compaction", agent.messages.items[0].object.get("type").?.string);
    try std.testing.expectEqualStrings("BLOB", agent.messages.items[0].object.get("encrypted_content").?.string);
    try std.testing.expectEqual(@as(u64, 0), agent.last_context_tokens);
    try std.testing.expectEqual(@as(u32, 1), agent.history_rewrites);
}

test "installCompactionItem refuses malformed responses and leaves history intact (#502)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    agent.arena = a;
    try agent.messages.append(try item(a, "message", null));
    for ([_][]const u8{
        "not json",
        "{\"output\":[]}",
        "{\"output\":[{\"type\":\"message\"}]}",
        "{\"output\":[{\"type\":\"compaction\"}]}", // no encrypted_content
    }) |bad| {
        try std.testing.expect(!installCompactionItem(&agent, bad));
        try std.testing.expectEqual(@as(usize, 1), agent.messages.items.len);
        try std.testing.expectEqual(@as(u32, 0), agent.history_rewrites);
    }
}

test "explicitCompact anti-thrash: a fresh blob head with little growth refuses (#502)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    agent.arena = a;
    agent.provider.id = "xai"; // serverCompactUrl fires for xai + .responses
    try agent.messages.append(try item(a, "compaction", null));
    try agent.messages.append(try item(a, "message", null));
    // Guard trips BEFORE any network I/O — false, history untouched.
    try std.testing.expect(!explicitCompact(&agent));
    try std.testing.expectEqual(@as(usize, 2), agent.messages.items.len);
    try std.testing.expectEqual(@as(u32, 0), agent.history_rewrites);
}

test "manualCompact (#804): unsupported opaque history reports failure instead of a successful no-op" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    const saved_wire = provider.g_xai_responses;
    provider.g_xai_responses = true;
    defer provider.g_xai_responses = saved_wire;
    agent.provider = .{ .id = "xai", .kind = .responses, .auth = .bearer, .url = provider.xai_responses_url, .api_key = "k", .model = "grok-4.6", .context = 100_000 };
    // History = one opaque compaction item + one turn: small and blob-anchored,
    // so the anti-thrash guard refuses the endpoint before any POST — and the
    // fallback must NOT be a client summary (it cannot see inside the blob).
    var blob: std.json.ObjectMap = .empty;
    try blob.put(a, "type", .{ .string = "compaction" });
    try blob.put(a, "encrypted_content", .{ .string = "opaque" });
    try agent.messages.append(.{ .object = blob });
    try agent.messages.append(try item(a, "message", null));
    try std.testing.expectError(error.ServerCompactionRequired, manualCompact(&agent));
    try std.testing.expectEqual(@as(usize, 2), agent.messages.items.len); // untouched
}

test "standalone compaction window survives pruning and save restore until a new blob (#804)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    const response = try std.json.parseFromSliceLeaky(Value, a,
        \\{"output":[{"type":"message","role":"user","content":"retained"},{"type":"compaction","encrypted_content":"old"},{"type":"message","role":"assistant","content":"retained too"}]}
    , .{});
    _ = try installCompactedOutput(&agent, response);
    const before = try std.json.Stringify.valueAlloc(a, Value{ .array = agent.messages }, .{});
    try std.testing.expect(!pruneIf(&agent, true));
    // Simulate the exact provenance field the session serializer/loader carries.
    var aw: Io.Writer.Allocating = .init(a);
    var s: std.json.Stringify = .{ .writer = &aw.writer };
    try s.beginObject();
    try agent.compaction_window.write(&s);
    try s.endObject();
    const saved = try std.json.parseFromSliceLeaky(Value, a, aw.written(), .{});
    agent.compaction_window = try @import("compaction_window.zig").State.restore(a, saved.object, agent.messages.items);
    autocompactIf(&agent, 85_000, true);
    const after = try std.json.Stringify.valueAlloc(a, Value{ .array = agent.messages }, .{});
    try std.testing.expectEqualStrings(before, after);
    const body = try compactBody(&agent);
    const request = try std.json.parseFromSliceLeaky(Value, a, body, .{});
    const input = try std.json.Stringify.valueAlloc(a, request.object.get("input").?, .{});
    try std.testing.expectEqualStrings(before, input);
    // Only a distinct, newly returned in-stream blob may retire the window.
    const next = try std.json.parseFromSliceLeaky(Value, a, "{\"type\":\"compaction\",\"encrypted_content\":\"new\"}", .{});
    try agent.messages.append(next);
    try agent.messages.append(try item(a, "function_call", "c1"));
    try agent.messages.append(try item(a, "function_call_output", "c1"));
    try std.testing.expect(pruneIf(&agent, true));
    try std.testing.expectEqual(@as(usize, 3), agent.messages.items.len);
    try std.testing.expect(agent.compaction_window.canonical_blob == null);
}

test "legacy saved compaction windows retain their prefix (#804)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses);
    try agent.messages.append(try item(a, "message", null));
    try agent.messages.append(try item(a, "compaction", null));
    agent.compaction_window = try @import("compaction_window.zig").State.restore(a, .empty, agent.messages.items);
    try std.testing.expect(!pruneIf(&agent, true));
    try std.testing.expectEqual(@as(usize, 2), agent.messages.items.len);
    // An explicit null belongs to a newer save whose blob was automatic.
    var obj: std.json.ObjectMap = .empty;
    try obj.put(a, "canonical_compaction", .null);
    agent.compaction_window = try @import("compaction_window.zig").State.restore(a, obj, agent.messages.items);
    try std.testing.expect(pruneIf(&agent, true));
}

test "local compaction rejects opaque items anywhere without changing history (#804)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    for ([_][]const u8{ "compaction", "compaction_summary" }) |kind| {
        var agent = testAgent(a, .responses);
        try agent.messages.append(try item(a, "message", null));
        try agent.messages.append(try item(a, kind, null));
        try std.testing.expectError(error.ServerCompactionRequired, agent.compact());
        try std.testing.expectEqual(@as(usize, 2), agent.messages.items.len);
        try std.testing.expectEqual(@as(u32, 0), agent.history_rewrites);
    }
}

test "opaque recovery failure is visible and never emergency trims (#804)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var agent = testAgent(a, .responses); // unsupported server route, no network
    agent.compact_pin_degraded = false;
    agent.compact_stall = .{};
    agent.compact_transport_failures = 1;
    var aw: Io.Writer.Allocating = .init(a);
    agent.out = &aw.writer;
    const was_json = main_mod.json_mode;
    main_mod.json_mode = false;
    defer main_mod.json_mode = was_json;
    try agent.messages.append(try item(a, "compaction", null));
    for (0..20) |_| try agent.messages.append(try item(a, "message", null));
    agent.compactOrRecover(true);
    try std.testing.expectEqual(@as(usize, 21), agent.messages.items.len);
    try std.testing.expectEqual(@as(u32, 0), agent.history_rewrites);
    try std.testing.expectEqual(@as(u8, 1), agent.compact_transport_failures);
    try std.testing.expect(std.mem.indexOf(u8, aw.written(), "auto-compaction failed: ServerCompactionRequired") != null);
}

test "near-limit opaque recovery uses the standalone server and preserves failed output (#804)" {
    const io = std.testing.io;
    const Server = struct {
        fn run(io_: Io, server: *Io.net.Server, payload: []const u8, saw: *std.atomic.Value(bool)) void {
            const conn = server.accept(io_) catch return;
            defer conn.close(io_);
            var rbuf: [8192]u8 = undefined;
            var reader = Io.net.Stream.Reader.init(conn, io_, &rbuf);
            const line = (reader.interface.takeDelimiter('\n') catch return) orelse return;
            const route_ok = std.mem.startsWith(u8, line, "POST /responses/compact ");
            var length: usize = 0;
            while (true) {
                const header = (reader.interface.takeDelimiter('\n') catch return) orelse return;
                if (std.mem.eql(u8, header, "\r")) break;
                if (std.ascii.startsWithIgnoreCase(header, "content-length:"))
                    length = std.fmt.parseInt(usize, std.mem.trim(u8, header[15..], " \r"), 10) catch return;
            }
            const body = reader.interface.take(length) catch return;
            saw.store(route_ok and std.mem.indexOf(u8, body, "old-state") != null, .release);
            var wbuf: [1024]u8 = undefined;
            var writer = Io.net.Stream.Writer.init(conn, io_, &wbuf);
            writer.interface.print("HTTP/1.1 200 OK\r\ncontent-length: {d}\r\nconnection: close\r\n\r\n{s}", .{ payload.len, payload }) catch return;
            writer.interface.flush() catch {};
        }
    };
    for ([_]bool{ true, false }) |success| {
        var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
        defer arena_state.deinit();
        const a = arena_state.allocator();
        var addr = try Io.net.IpAddress.parseLiteral("127.0.0.1:0");
        var server = try Io.net.IpAddress.listen(&addr, io, .{});
        defer server.deinit(io);
        var saw: std.atomic.Value(bool) = .init(false);
        var group: Io.Group = .init;
        defer group.cancel(io);
        const payload = if (success)
            "{\"output\":[{\"type\":\"message\",\"role\":\"user\",\"content\":\"keep\"},{\"type\":\"compaction\",\"encrypted_content\":\"new-state\"}]}"
        else
            "{\"output\":[]}";
        try group.concurrent(io, Server.run, .{ io, &server, payload, &saw });
        var client: std.http.Client = .{ .allocator = a, .io = io };
        defer client.deinit();
        var agent = testAgent(a, .responses);
        agent.io = io;
        agent.client = &client;
        agent.tracer = null;
        agent.provider.id = "openai";
        agent.provider.url = try std.fmt.allocPrint(a, "http://127.0.0.1:{d}/responses", .{server.socket.address.getPort()});
        agent.compact_pin_degraded = false;
        agent.compact_stall = .{};
        agent.compact_transport_failures = 1;
        var aw: Io.Writer.Allocating = .init(a);
        agent.out = &aw.writer;
        const blob = try std.json.parseFromSliceLeaky(Value, a, "{\"type\":\"compaction\",\"encrypted_content\":\"old-state\"}", .{});
        try agent.messages.append(blob);
        try agent.messages.append(try item(a, "message", null));
        autocompactIf(&agent, 96_000, true);
        try std.testing.expect(saw.load(.acquire));
        try std.testing.expectEqual(@as(usize, 2), agent.messages.items.len);
        try std.testing.expectEqual(@as(u32, if (success) 1 else 0), agent.history_rewrites);
        if (success) {
            try std.testing.expect(!pruneIf(&agent, true));
            try std.testing.expectEqualStrings("new-state", agent.messages.items[1].object.get("encrypted_content").?.string);
        } else {
            try std.testing.expectEqualStrings("old-state", agent.messages.items[0].object.get("encrypted_content").?.string);
            try std.testing.expect(std.mem.indexOf(u8, aw.written(), "auto-compaction failed") != null);
            try std.testing.expect(std.mem.indexOf(u8, aw.written(), "falling back to local") == null);
        }
    }
}