Skip to content

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.json
index 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.zig
index 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.Reque
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);
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.zig
index 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.zig
index 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.zig
index 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.zig
index 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.zig
index 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.zig
index 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.zig
index 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.zig
index 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: []cons
var 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 null
else
diff --git a/src/mcp_cache.zig b/src/mcp_cache.zig
index 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.zig
index 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_sc
if (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.zig
index 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.zig
index 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").Pr
for (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.zig
index 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.zig
index 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) []c
if (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.zig
index 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.zig
index 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: []co
if (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.zig
index 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.zig
index 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) void
n.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.zig
index 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) Allocato
const 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.zig
index 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.Sessi
const 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.zig
index 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(SessionEn
defer 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.zig
index 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.zig
new file mode 100644
index 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.zig
index 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;
}