graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs
Python
Compile one stable sort instead of one per element type
Rach Pradhan65f69ed55bfc
diff --git a/scripts/eval/tier1-manifest.json b/scripts/eval/tier1-manifest.jsonindex 0cd4cd30..6d672719 100644--- a/scripts/eval/tier1-manifest.json+++ b/scripts/eval/tier1-manifest.json@@ -14,7 +14,7 @@"src/main.zig","src/repl.zig"],- "test_count_baseline": 3487,+ "test_count_baseline": 3489,"test_count_slack": 25,"required_invariants": [{diff --git a/src/acp.zig b/src/acp.zigindex 5c2637c8..a58cecc5 100644--- a/src/acp.zig+++ b/src/acp.zig@@ -147,7 +147,7 @@ fn liveModels(ctx: *anyopaque, arena: Allocator, w: *Io.Writer, req: proto.Requebilling.costFor(m.provider, keys.source(m.provider)),),};- std.mem.sort(models_rank.Scored, ranked, {}, models_rank.scoredLess);+ @import("stable_sort.zig").sort(models_rank.Scored, ranked, {}, models_rank.scoredLess);const rows = try arena.alloc(Row, catalog.len);for (ranked, rows) |r, *row| {const m = catalog[r.idx];diff --git a/src/acp_agent_activity.zig b/src/acp_agent_activity.zigindex 7ce78c55..6bcb32e3 100644--- a/src/acp_agent_activity.zig+++ b/src/acp_agent_activity.zig@@ -18,7 +18,7 @@ pub fn list(a: A, io: Io, dir: Io.Dir) ![]activity.Meta {const row = std.json.parseFromSliceLeaky(activity.Meta, a, bytes, .{ .ignore_unknown_fields = true }) catch continue;if (activity.validId(row.id)) try rows.append(a, row);}- std.mem.sort(activity.Meta, rows.items, {}, struct {+ @import("stable_sort.zig").sort(activity.Meta, rows.items, {}, struct {fn less(_: void, x: activity.Meta, y: activity.Meta) bool {return x.updatedAt > y.updatedAt;}diff --git a/src/acp_agents.zig b/src/acp_agents.zigindex 4c773a61..400a7e90 100644--- a/src/acp_agents.zig+++ b/src/acp_agents.zig@@ -137,7 +137,7 @@ pub fn handle(a: A, io: Io, home: []const u8, out: *Io.Writer, req: proto.Reques};if (relevant) try messages.append(a, m);}- std.mem.sort(chan.Message, messages.items, {}, struct {+ @import("stable_sort.zig").sort(chan.Message, messages.items, {}, struct {fn less(_: void, x: chan.Message, y: chan.Message) bool {return x.ts_ms < y.ts_ms;}diff --git a/src/acp_model_option.zig b/src/acp_model_option.zigindex 0e675ac8..4fa53e3b 100644--- a/src/acp_model_option.zig+++ b/src/acp_model_option.zig@@ -45,7 +45,7 @@ pub fn choices(arena: Allocator, catalog: []const pricing.ModelInfo, keys: anyty.idx = i,.score = models_rank.electionRank(keys.get(m.provider) != null, billing.costFor(m.provider, keys.source(m.provider))),};- std.mem.sort(models_rank.Scored, ranked, {}, models_rank.scoredLess);+ @import("stable_sort.zig").sort(models_rank.Scored, ranked, {}, models_rank.scoredLess);var out: std.ArrayList(Choice) = .empty;try out.append(arena, current);for (ranked) |r| {diff --git a/src/additional_tests.zig b/src/additional_tests.zigindex 40c2e590..a2708af3 100644--- a/src/additional_tests.zig+++ b/src/additional_tests.zig@@ -4,6 +4,7 @@ const readline_commit = @import("readline_commit.zig");test {_ = @import("readline_history.zig");+ _ = @import("stable_sort.zig");_ = @import("codedbpro_paths.zig");_ = @import("agent_request_body_responses.zig");_ = @import("agent_server_compact_tests.zig");diff --git a/src/brief_diversity.zig b/src/brief_diversity.zigindex 75608725..bdba9071 100644--- a/src/brief_diversity.zig+++ b/src/brief_diversity.zig@@ -179,7 +179,7 @@ fn gramSet(out: []u64, words: []const u64) []const u64 {}}const filled = out[0..n];- std.mem.sort(u64, filled, {}, std.sort.asc(u64));+ @import("stable_sort.zig").sort(u64, filled, {}, std.sort.asc(u64));var w: usize = 0;for (filled, 0..) |v, k| {if (k == 0 or v != filled[w - 1]) {diff --git a/src/job_registry.zig b/src/job_registry.zigindex 4fcd36ca..6d7ed986 100644--- a/src/job_registry.zig+++ b/src/job_registry.zig@@ -85,7 +85,7 @@ pub fn list(io: Io, arena: Allocator, base: []const u8) []const Record {const rec = std.json.parseFromSliceLeaky(Record, arena, data, .{ .ignore_unknown_fields = true }) catch continue;out.append(arena, rec) catch break;}- std.mem.sort(Record, out.items, {}, earlier);+ @import("stable_sort.zig").sort(Record, out.items, {}, earlier);return out.items;}diff --git a/src/list_dir.zig b/src/list_dir.zigindex 005ca464..3871d2bf 100644--- a/src/list_dir.zig+++ b/src/list_dir.zig@@ -171,7 +171,7 @@ fn nameLess(_: void, a: *Node, b: *Node) bool {fn sortTree(n: *Node, partial: bool) void {n.partial = partial;- std.mem.sort(*Node, n.kids.items, {}, nameLess);+ @import("stable_sort.zig").sort(*Node, n.kids.items, {}, nameLess);for (n.kids.items) |k| sortTree(k, partial);}@@ -187,7 +187,7 @@ fn summary(arena: Allocator, n: *Node) ![]const u8 {var pairs: std.ArrayList(ExtPair) = .empty;var it = n.ext.iterator();while (it.next()) |e| try pairs.append(arena, .{ .k = e.key_ptr.*, .n = e.value_ptr.* });- std.mem.sort(ExtPair, pairs.items, {}, extLess);+ @import("stable_sort.zig").sort(ExtPair, pairs.items, {}, extLess);const take = @min(pairs.items.len, top_k_exts);var aw: Io.Writer.Allocating = .init(arena);const word: []const u8 = if (n.file_count == 1) "file" else "files";diff --git a/src/list_dir_nearmiss.zig b/src/list_dir_nearmiss.zigindex 51916bb2..547666d4 100644--- a/src/list_dir_nearmiss.zig+++ b/src/list_dir_nearmiss.zig@@ -117,7 +117,7 @@ fn suggestBudget(io: Io, arena: Allocator, resolved: []const u8, display: []consvar aw: Io.Writer.Allocating = .init(arena);const w = &aw.writer;- std.mem.sort(Entry, entries.items, {}, byDist);+ @import("stable_sort.zig").sort(Entry, entries.items, {}, byDist);var close: usize = 0;for (entries.items) |e| {if (e.dist > threshold(leaf) or close == max_close) break;@@ -126,7 +126,7 @@ fn suggestBudget(io: Io, arena: Allocator, resolved: []const u8, display: []cons}if (close > 0) w.writeAll(".") catch return null;- std.mem.sort(Entry, entries.items, {}, byName);+ @import("stable_sort.zig").sort(Entry, entries.items, {}, byName);if (limited)w.print(" Visible entries among {d} scanned in {s} ({d}): ", .{ scanned, parent_display, entries.items.len }) catch return nullelsediff --git a/src/mcp_cache.zig b/src/mcp_cache.zigindex 6f0cf5dc..ed57c95e 100644--- a/src/mcp_cache.zig+++ b/src/mcp_cache.zig@@ -56,7 +56,7 @@ pub fn keyFor(arena: Allocator, cfg: std.json.ObjectMap) []const u8 {/// Order-independent hash of an `env` object's pairs.fn envHash(arena: Allocator, env: std.json.ObjectMap) u64 {const keys = arena.dupe([]const u8, env.keys()) catch return 0;- std.mem.sort([]const u8, keys, {}, struct {+ @import("stable_sort.zig").sort([]const u8, keys, {}, struct {fn lt(_: void, x: []const u8, y: []const u8) bool {return std.mem.lessThan(u8, x, y);}diff --git a/src/mcp_select.zig b/src/mcp_select.zigindex 5e402785..47d65244 100644--- a/src/mcp_select.zig+++ b/src/mcp_select.zig@@ -60,7 +60,7 @@ pub fn searchInto(arena: Allocator, all: []const mcp.Tool, input: Value) !mcp_scif (hits.items.len == 0) {return .{ .text = try std.fmt.allocPrint(arena, "no deferred MCP tool matched '{s}'. Use load_tool_schemas with no args to list what is deferred.", .{query}), .is_error = true };}- std.mem.sort(@TypeOf(hits.items[0]), hits.items, {}, struct {+ @import("stable_sort.zig").sort(@TypeOf(hits.items[0]), hits.items, {}, struct {fn lessThan(_: void, a: @TypeOf(hits.items[0]), b: @TypeOf(hits.items[0])) bool {return a.score > b.score;}diff --git a/src/models_table.zig b/src/models_table.zigindex 2853bb00..b436cc7f 100644--- a/src/models_table.zig+++ b/src/models_table.zig@@ -54,7 +54,7 @@ pub fn writeRows(),};}- std.mem.sort(models_rank.Scored, ranked, {}, models_rank.scoredLess);+ @import("stable_sort.zig").sort(models_rank.Scored, ranked, {}, models_rank.scoredLess);for (ranked) |r| {const m = models[r.idx];try writeRow(out, .{diff --git a/src/native_fold.zig b/src/native_fold.zigindex 574d0051..34bec995 100644--- a/src/native_fold.zig+++ b/src/native_fold.zig@@ -307,7 +307,7 @@ pub fn renderLoadedTail(s: *std.json.Stringify, kind: @import("provider.zig").Prfor (mcp_tools) |m| if (mcp_schema_gate.policyDeferred(mcp_tools, m)) {if (mcp_schema_gate.loadSeq(m.qualified_name)) |seq| try loaded.append(out, .{ .seq = seq, .external = m });};- std.mem.sort(Entry, loaded.items, {}, struct {+ @import("stable_sort.zig").sort(Entry, loaded.items, {}, struct {fn lt(_: void, a: Entry, b: Entry) bool {return a.seq < b.seq;}diff --git a/src/orchestration_policy.zig b/src/orchestration_policy.zigindex 2efb9b84..60c23f0f 100644--- a/src/orchestration_policy.zig+++ b/src/orchestration_policy.zig@@ -210,7 +210,7 @@ pub const ArmObs = struct {var buf: [max_call_samples]u32 = @splat(0);@memcpy(buf[0..self.n_calls], self.calls[0..self.n_calls]);const s = buf[0..self.n_calls];- std.mem.sort(u32, s, {}, std.sort.asc(u32));+ @import("stable_sort.zig").sort(u32, s, {}, std.sort.asc(u32));// Nearest-rank: ceil(0.9 * n), 1-based, clamped into the slice.const rank = (self.n_calls * 9 + 9) / 10;return s[@min(rank, s.len) - 1];diff --git a/src/peer_cli.zig b/src/peer_cli.zigindex 7a56eef6..000f408d 100644--- a/src/peer_cli.zig+++ b/src/peer_cli.zig@@ -303,7 +303,7 @@ pub fn history(io: Io, arena: Allocator, ctx: Ctx, last: usize, window: u64) []cif (sees) out.append(arena, .{ .room = r.room, .m = m }) catch break;}}- std.mem.sort(Heard, out.items, {}, struct {+ @import("stable_sort.zig").sort(Heard, out.items, {}, struct {fn lt(_: void, a: Heard, b: Heard) bool {return a.m.ts_ms < b.m.ts_ms;}diff --git a/src/peer_live.zig b/src/peer_live.zigindex c2b8de5b..41807190 100644--- a/src/peer_live.zig+++ b/src/peer_live.zig@@ -35,7 +35,7 @@ fn field(out: *std.Io.Writer, text: []const u8) !void {pub fn write(arena: std.mem.Allocator, out: *std.Io.Writer, peers: []const Owner, mine: []const u8, now: i64) !void {const sorted = try arena.dupe(Owner, peers);defer arena.free(sorted);- std.mem.sort(Owner, sorted, {}, lessThan);+ @import("stable_sort.zig").sort(Owner, sorted, {}, lessThan);for ([_]bool{ true, false }) |local_group| {var heading = false;for (sorted) |p| {diff --git a/src/pickers.zig b/src/pickers.zigindex dae31274..13ccf829 100644--- a/src/pickers.zig+++ b/src/pickers.zig@@ -263,7 +263,7 @@ pub fn modelPicker(root: *Agent, keys: *Keys, arena: Allocator, out: *Io.Writer)scored.append(arena, .{ .idx = i, .score = s + models_rank.electionRank(has_key, seat) }) catch {};}}- std.mem.sort(Scored, scored.items, {}, scoredLess);+ @import("stable_sort.zig").sort(Scored, scored.items, {}, scoredLess);for (scored.items) |s| filtered.append(arena, s.idx) catch {};if (filtered.items.len == 0) sel = 0 else if (sel >= filtered.items.len) sel = filtered.items.len - 1;if (select_current) {@@ -390,7 +390,7 @@ pub fn listPickerAt(root: *Agent, arena: Allocator, out: *Io.Writer, title: []coif (pickScore(item, query.items)) |s|scored.append(arena, .{ .idx = i, .score = s }) catch {};}- std.mem.sort(Scored, scored.items, {}, scoredLess);+ @import("stable_sort.zig").sort(Scored, scored.items, {}, scoredLess);filtered.clearRetainingCapacity();for (scored.items) |s| filtered.append(arena, s.idx) catch {};if (filtered.items.len == 0) sel = 0 else if (sel >= filtered.items.len) sel = filtered.items.len - 1;diff --git a/src/readline_paste.zig b/src/readline_paste.zigindex 684cb46a..020228a6 100644--- a/src/readline_paste.zig+++ b/src/readline_paste.zig@@ -59,7 +59,7 @@ pub const Store = struct {.label = label,.body = owned_body,});- std.mem.sort(Entry, self.entries.items, {}, lessThan);+ @import("stable_sort.zig").sort(Entry, self.entries.items, {}, lessThan);cursor.* += label.len;}diff --git a/src/repo_map.zig b/src/repo_map.zigindex c4aba75e..2a387bd8 100644--- a/src/repo_map.zig+++ b/src/repo_map.zig@@ -85,7 +85,7 @@ fn readChildren(io: Io, arena: Allocator, root: []const u8, parent: *Node) voidn.top = if (parent.depth == 0) n else parent.top;parent.kids.append(arena, n) catch continue;}- std.mem.sort(*Node, parent.kids.items, {}, nodeLt);+ @import("stable_sort.zig").sort(*Node, parent.kids.items, {}, nodeLt);}fn take(b: *Budget, n: *Node) void {diff --git a/src/sandbox.zig b/src/sandbox.zigindex 1506af4d..a5560eaf 100644--- a/src/sandbox.zig+++ b/src/sandbox.zig@@ -272,7 +272,7 @@ pub fn list(io: Io, dir: Io.Dir, arena: Allocator, session: []const u8) Allocatoconst m = parseManifest(arena, bytes) orelse continue;try found.append(arena, m);}- std.mem.sort(Manifest, found.items, {}, byCapture);+ @import("stable_sort.zig").sort(Manifest, found.items, {}, byCapture);return found.items;}diff --git a/src/session_discovery.zig b/src/session_discovery.zigindex fcd2cfe9..e3ab7848 100644--- a/src/session_discovery.zig+++ b/src/session_discovery.zig@@ -128,7 +128,7 @@ pub fn listAll(root: *Agent, arena: Allocator) std.ArrayList(session_index.Sessiconst home = root.home;if (home.len > 0 and !session_index.sameWorkspace(home, cwd))session_index.appendWorkspaceSessions(root.io, arena, &entries, home, false);- std.mem.sort(session_index.SessionEntry, entries.items, {}, struct {+ @import("stable_sort.zig").sort(session_index.SessionEntry, entries.items, {}, struct {fn newer(_: void, a: session_index.SessionEntry, b: session_index.SessionEntry) bool {if (a.local != b.local) return a.local;return a.updated_ms > b.updated_ms;diff --git a/src/session_index.zig b/src/session_index.zigindex a4fcfc40..39850ac6 100644--- a/src/session_index.zig+++ b/src/session_index.zig@@ -178,7 +178,7 @@ pub fn listSavedSessions(root: *Agent, arena: Allocator) std.ArrayList(SessionEndefer dir.close(root.io);const cwd = if (main_mod.g_cwd_display.len > 0) main_mod.g_cwd_display else ".";const entries = listFromDir(root.io, arena, dir, cwd, true);- std.mem.sort(SessionEntry, entries.items, {}, newerFirst);+ @import("stable_sort.zig").sort(SessionEntry, entries.items, {}, newerFirst);return entries;}@@ -204,7 +204,7 @@ pub fn listSavedSessionsAll(root: *Agent, arena: Allocator) std.ArrayList(Sessio}if (!seen) entries.append(arena, e) catch {};}- std.mem.sort(SessionEntry, entries.items, {}, newerFirst);+ @import("stable_sort.zig").sort(SessionEntry, entries.items, {}, newerFirst);return entries;}diff --git a/src/skill_docs.zig b/src/skill_docs.zigindex 6b933140..218204a6 100644--- a/src/skill_docs.zig+++ b/src/skill_docs.zig@@ -309,7 +309,7 @@ pub fn promptCatalog(arena: Allocator, list: []const Skill) []const u8 {if (list.len == 0) return "";const order = arena.alloc(usize, list.len) catch return "";for (order, 0..) |*o, i| o.* = i;- std.mem.sort(usize, order, list, struct {+ @import("stable_sort.zig").sort(usize, order, list, struct {fn lessThan(ctx: []const Skill, a: usize, b: usize) bool {return std.mem.order(u8, ctx[a].name, ctx[b].name) == .lt;}diff --git a/src/stable_sort.zig b/src/stable_sort.zignew file mode 100644index 00000000..f3299e04--- /dev/null+++ b/src/stable_sort.zig@@ -0,0 +1,139 @@+//! One stable sort for every element type. `std.mem.sort` instantiates its+//! block sort per element type and comparator, ~18 KB of machine code each in+//! a release build; graff's two dozen call sites cost about half a megabyte.+//! Here the merge sort is compiled once and works on bytes; each call site+//! adds only a small comparator thunk. Same contract as `std.mem.sort`:+//! stable, ascending by `lessThanFn`.++const std = @import("std");++const Less = *const fn (ctx: *const anyopaque, a: *const anyopaque, b: *const anyopaque) bool;++/// Drop-in for `std.mem.sort`.+pub fn sort(+ comptime T: type,+ items: []T,+ context: anytype,+ comptime lessThanFn: fn (@TypeOf(context), lhs: T, rhs: T) bool,+) void {+ if (@sizeOf(T) == 0 or items.len < 2) return;+ const Ctx = @TypeOf(context);+ const Thunk = struct {+ fn less(ctx: *const anyopaque, a: *const anyopaque, b: *const anyopaque) bool {+ const c: *const Ctx = @ptrCast(@alignCast(ctx));+ const x: *const T = @ptrCast(@alignCast(a));+ const y: *const T = @ptrCast(@alignCast(b));+ return lessThanFn(c.*, x.*, y.*);+ }+ };+ const ctx_copy = context;+ sortBytes(+ @ptrCast(items.ptr),+ items.len,+ @sizeOf(T),+ .fromByteUnits(@alignOf(T)),+ @ptrCast(&ctx_copy),+ Thunk.less,+ );+}++/// Runs shorter than this are insertion-sorted in place before merging.+const run_len = 16;++fn sortBytes(base: [*]u8, n: usize, size: usize, alignment: std.mem.Alignment, ctx: *const anyopaque, less: Less) void {+ var start: usize = 0;+ while (start < n) : (start += run_len) insertion(base, start, @min(start + run_len, n), size, ctx, less);+ if (n <= run_len) return;++ // Merging needs a second buffer. Without one, finish with insertion sort:+ // still correct and stable, only slower on long lists.+ const gpa = std.heap.smp_allocator;+ const buf = gpa.rawAlloc(n * size, alignment, @returnAddress()) orelse+ return insertion(base, 0, n, size, ctx, less);+ defer gpa.rawFree(buf[0 .. n * size], alignment, @returnAddress());++ var src = base;+ var dst = buf;+ var width: usize = run_len;+ while (width < n) : (width *= 2) {+ var lo: usize = 0;+ while (lo < n) : (lo += 2 * width) {+ const mid = @min(lo + width, n);+ const hi = @min(lo + 2 * width, n);+ merge(src, dst, lo, mid, hi, size, ctx, less);+ }+ std.mem.swap([*]u8, &src, &dst);+ }+ if (src != base) @memcpy(base[0 .. n * size], src[0 .. n * size]);+}++fn insertion(base: [*]u8, lo: usize, hi: usize, size: usize, ctx: *const anyopaque, less: Less) void {+ var i = lo + 1;+ while (i < hi) : (i += 1) {+ var j = i;+ while (j > lo and less(ctx, base + j * size, base + (j - 1) * size)) : (j -= 1) {+ swapBytes(base + j * size, base + (j - 1) * size, size);+ }+ }+}++/// Merge src[lo..mid] and src[mid..hi] into dst[lo..hi]; ties keep the left run first.+fn merge(src: [*]const u8, dst: [*]u8, lo: usize, mid: usize, hi: usize, size: usize, ctx: *const anyopaque, less: Less) void {+ var i = lo;+ var j = mid;+ var k = lo;+ while (i < mid and j < hi) : (k += 1) {+ if (less(ctx, src + j * size, src + i * size)) {+ @memcpy(dst[k * size ..][0..size], src[j * size ..][0..size]);+ j += 1;+ } else {+ @memcpy(dst[k * size ..][0..size], src[i * size ..][0..size]);+ i += 1;+ }+ }+ if (i < mid) @memcpy(dst[k * size .. hi * size], src[i * size .. mid * size]);+ if (j < hi) @memcpy(dst[k * size .. hi * size], src[j * size .. hi * size]);+}++fn swapBytes(a: [*]u8, b: [*]u8, size: usize) void {+ for (a[0..size], b[0..size]) |*x, *y| std.mem.swap(u8, x, y);+}++const Pair = struct { key: u32, seq: u32 };++fn byKey(_: void, a: Pair, b: Pair) bool {+ return a.key < b.key;+}++test "sort is stable and matches std.mem.sort across run boundaries" {+ var prng = std.Random.DefaultPrng.init(0x5eed);+ const rand = prng.random();+ for ([_]usize{ 0, 1, 2, 15, 16, 17, 31, 33, 100, 1000, 4097 }) |n| {+ const ours = try std.testing.allocator.alloc(Pair, n);+ defer std.testing.allocator.free(ours);+ const want = try std.testing.allocator.alloc(Pair, n);+ defer std.testing.allocator.free(want);+ for (ours, 0..) |*p, i| p.* = .{ .key = rand.uintLessThan(u32, 8), .seq = @intCast(i) };+ @memcpy(want, ours);+ sort(Pair, ours, {}, byKey);+ std.mem.sort(Pair, want, {}, byKey);+ try std.testing.expectEqualSlices(Pair, want, ours);+ }+}++test "sort passes its context and handles slices and pointers" {+ const Desc = struct {+ fn less(flip: bool, a: []const u8, b: []const u8) bool {+ const lt = std.mem.lessThan(u8, a, b);+ return if (flip) !lt and !std.mem.eql(u8, a, b) else lt;+ }+ };+ var words = [_][]const u8{ "pear", "apple", "fig", "kiwi", "banana" };+ sort([]const u8, &words, true, Desc.less);+ try std.testing.expectEqualStrings("pear", words[0]);+ try std.testing.expectEqualStrings("apple", words[4]);++ var nums = [_]u64{ 9, 3, 7, 1 };+ sort(u64, &nums, {}, std.sort.asc(u64));+ try std.testing.expectEqualSlices(u64, &.{ 1, 3, 7, 9 }, &nums);+}diff --git a/src/subagent_activity.zig b/src/subagent_activity.zigindex ae2d53a1..d55ded35 100644--- a/src/subagent_activity.zig+++ b/src/subagent_activity.zig@@ -203,7 +203,7 @@ pub const Recorder = struct {if (!validId(meta.id) or std.mem.eql(u8, meta.status, "working")) continue;completed.append(a, meta) catch return;}- std.mem.sort(Meta, completed.items, {}, struct {+ @import("stable_sort.zig").sort(Meta, completed.items, {}, struct {fn less(_: void, x: Meta, y: Meta) bool {return x.updatedAt > y.updatedAt;}