graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs
Python
acp: the final session save no longer reads a freed workspace path
justrachf8c356cd3796
diff --git a/src/main.zig b/src/main.zigindex 53551369..6df9e723 100644--- a/src/main.zig+++ b/src/main.zig@@ -561,7 +561,7 @@ const exec = @import("exec.zig");test { // ── Unit tests (`zig build test`): pull in tests from imported modules (mcp.zig)_ = .{ @import("beta_feed.zig"), @import("jev_tool.zig"), @import("jev_model_scope.zig"), @import("jev_provider_switch_tests.zig"), @import("jev_effort_state.zig"), @import("gemini_turns.zig"), @import("gemini_turns_tests.zig") };_ = .{ @import("mcp_apps.zig"), @import("html_view.zig"), @import("usage_trace.zig"), @import("providers_confirmation_tests.zig"), @import("repl_model_confirmation_tests.zig"), @import("repl_model_pick_tests.zig"), @import("engine_sink_citation_tests.zig"), @import("cite_markup_stream_tests.zig"), @import("oneshot_citation_tests.zig"), @import("acp_permission.zig"), @import("acp_usage.zig") };- _ = .{ @import("mcp_server_tests.zig"), @import("main_test.zig"), @import("artifact_claim_command.zig"), @import("cli_path_hint.zig"), @import("run_budget.zig") };+ _ = .{ @import("workspace_display.zig"), @import("session_finalize_tests.zig"), @import("mcp_server_tests.zig"), @import("main_test.zig"), @import("artifact_claim_command.zig"), @import("cli_path_hint.zig"), @import("run_budget.zig") };_ = .{ @import("session_catalog.zig"), @import("session_prompt.zig"), @import("session_discovery.zig"), @import("session_workspaces.zig"), @import("commands_resume.zig"), @import("peer_live.zig"), @import("presence_tests.zig"), @import("mcp_rpc_tests.zig") };_ = .{ @import("prompt_astra.zig"), @import("prompt_guidance.zig"), @import("oauth_chatgpt.zig"), @import("chatgpt_reauth.zig") }; // per-model guidance (Astra, GPT-5.6); ChatGPT plan sign-in (ADR 0253)_ = .{ @import("agent_empty_completion.zig"), @import("agent_model_loop.zig"), @import("publication_policy_tests.zig"), @import("jobs_completion_tests.zig") };diff --git a/src/session_finalize_tests.zig b/src/session_finalize_tests.zignew file mode 100644index 00000000..d6c20218--- /dev/null+++ b/src/session_finalize_tests.zig@@ -0,0 +1,65 @@+//! The last session save runs inside `finalizeSession`, after the process has+//! begun releasing its globals. Whatever that save serializes must still be+//! alive when it runs (#1193).++const std = @import("std");+const builtin = @import("builtin");+const Io = std.Io;+const Agent = @import("agent.zig").Agent;+const main_mod = @import("main.zig");++test "#1193 the final save records a switched workspace before releasing it" {+ if (builtin.os.tag == .windows) return error.SkipZigTest;+ const gpa = std.testing.allocator;+ const io = std.testing.io;+ const writer = @import("session_writer.zig");+ const transcript = @import("session_transcript.zig");+ writer.resetForTest();+ defer writer.resetForTest();+ transcript.resetForTest();+ defer transcript.resetForTest();++ var arena_state = std.heap.ArenaAllocator.init(gpa);+ defer arena_state.deinit();+ const arena = arena_state.allocator();+ var tmp = std.testing.tmpDir(.{});+ defer tmp.cleanup();+ var orig = try Io.Dir.cwd().openDir(io, ".", .{});+ defer orig.close(io);+ if (std.posix.system.fchdir(tmp.dir.handle) != 0) return error.ChdirFailed;+ defer _ = std.posix.system.fchdir(orig.handle);+ var home_buf: [std.fs.max_path_bytes]u8 = undefined;+ const home_len = std.process.currentPath(io, &home_buf) catch return error.SkipZigTest;++ const saved_display = main_mod.g_cwd_display;+ defer main_mod.g_cwd_display = saved_display;+ // What an ACP session/new or session/load into another folder does.+ @import("workspace_display.zig").adopt(gpa, "/work/switched-1193");++ var client: std.http.Client = .{ .allocator = gpa, .io = io };+ defer client.deinit();+ var keys: @import("provider.zig").Keys = .{ .values = @splat("test-key") };+ var root: Agent = .{+ .gpa = gpa,+ .arena = arena,+ .io = io,+ .client = &client,+ .provider = try keys.providerById("anthropic", "sonnet"),+ .messages = (try std.json.parseFromSliceLeaky(std.json.Value, arena, "[{\"role\":\"user\",\"content\":\"final save 1193\"}]", .{})).array,+ .sub = false,+ .label = "root",+ .out = null,+ .home = home_buf[0..home_len],+ .session_name = "finalize-1193",+ };+ var out_buf: [256]u8 = undefined;+ var out: Io.Writer.Discarding = .init(&out_buf);+ try @import("session_run.zig").finalizeSession(gpa, io, arena, &out.writer, &root, true);++ const bytes = try tmp.dir.readFileAlloc(io, ".graff/sessions/finalize-1193.session.json", arena, .limited(1 << 20));+ const parsed = try std.json.parseFromSliceLeaky(std.json.Value, arena, bytes, .{});+ const workspace = parsed.object.get("workspace") orelse return error.MissingWorkspace;+ try std.testing.expectEqualStrings("/work/switched-1193", workspace.string);+ // Released only after the save, and the global no longer aliases it.+ try std.testing.expectEqualStrings(".", main_mod.g_cwd_display);+}diff --git a/src/session_run.zig b/src/session_run.zigindex 15c494de..86584551 100644--- a/src/session_run.zig+++ b/src/session_run.zig@@ -471,7 +471,8 @@ pub fn finalizeSession(gpa: Allocator, io: Io, arena: Allocator, out: *Io.Writer// abandoned. Before presence.retire so the event can't outlive the flush.@import("task_outcome.zig").noteSessionEnd(root);@import("session_globals.zig").release(gpa, io); // retire presence, free gpa-owned globals- @import("workspace_switch.zig").deinitDisplay(gpa);+ // #1193: deferred past the final save, which writes g_cwd_display.+ defer @import("workspace_switch.zig").deinitDisplay(gpa);if (!json_mode and root.messages.items.len > 0) {const sink = engine_sink.writerSink(out);if (session.saveSession(root, arena, root.session_name)) |_| {diff --git a/src/workspace_display.zig b/src/workspace_display.zignew file mode 100644index 00000000..462c70a4--- /dev/null+++ b/src/workspace_display.zig@@ -0,0 +1,91 @@+//! Ownership of the workspace display path a mid-session switch adopts.+//!+//! `main.g_cwd_display` is read without a lock by the session save, tool+//! paths, permission prompts and ACP streaming, some of them on other threads.+//! A switch therefore never frees the display it replaces: every adopted path+//! stays alive until `deinit`, which the session runs after its final save, and+//! `deinit` leaves the global on static memory instead of on freed bytes.++const std = @import("std");+const Allocator = std.mem.Allocator;+const main_mod = @import("main.zig");++var g_adopted: std.ArrayList([]u8) = .empty;++/// Point `g_cwd_display` at a gpa-owned copy of `path`. Best effort: on OOM the+/// previous display stays (it is still valid memory).+pub fn adopt(gpa: Allocator, path: []const u8) void {+ g_adopted.ensureUnusedCapacity(gpa, 1) catch return;+ const owned = gpa.dupe(u8, path) catch return;+ g_adopted.appendAssumeCapacity(owned);+ main_mod.g_cwd_display = owned;+}++/// Free every display this process adopted. Teardown only: after this, no+/// reader may run, and the global no longer aliases any of the freed copies.+pub fn deinit(gpa: Allocator) void {+ for (g_adopted.items) |owned| {+ if (main_mod.g_cwd_display.ptr == owned.ptr) main_mod.g_cwd_display = ".";+ gpa.free(owned);+ }+ g_adopted.deinit(gpa);+ g_adopted = .empty;+}++/// Counts frees so a test can tell "retired" from "freed" without reading+/// freed memory.+const FreeCounter = struct {+ child: Allocator,+ frees: usize = 0,++ fn allocator(self: *FreeCounter) Allocator {+ return .{ .ptr = self, .vtable = &.{ .alloc = alloc, .resize = resize, .remap = remap, .free = free } };+ }+ fn alloc(ctx: *anyopaque, len: usize, a: std.mem.Alignment, ra: usize) ?[*]u8 {+ const self: *FreeCounter = @ptrCast(@alignCast(ctx));+ return self.child.rawAlloc(len, a, ra);+ }+ fn resize(ctx: *anyopaque, m: []u8, a: std.mem.Alignment, n: usize, ra: usize) bool {+ const self: *FreeCounter = @ptrCast(@alignCast(ctx));+ return self.child.rawResize(m, a, n, ra);+ }+ fn remap(ctx: *anyopaque, m: []u8, a: std.mem.Alignment, n: usize, ra: usize) ?[*]u8 {+ const self: *FreeCounter = @ptrCast(@alignCast(ctx));+ return self.child.rawRemap(m, a, n, ra);+ }+ fn free(ctx: *anyopaque, m: []u8, a: std.mem.Alignment, ra: usize) void {+ const self: *FreeCounter = @ptrCast(@alignCast(ctx));+ self.frees += 1;+ self.child.rawFree(m, a, ra);+ }+};++test "#1193 a workspace switch keeps the replaced display alive until teardown" {+ var counter: FreeCounter = .{ .child = std.testing.allocator };+ const gpa = counter.allocator();+ const saved = main_mod.g_cwd_display;+ defer main_mod.g_cwd_display = saved;++ adopt(gpa, "/work/first-1193");+ const first = main_mod.g_cwd_display;+ adopt(gpa, "/work/second-1193");+ // An unlocked reader that captured the first display must still see it.+ try std.testing.expectEqual(@as(usize, 0), counter.frees);+ try std.testing.expectEqualStrings("/work/first-1193", first);+ try std.testing.expectEqualStrings("/work/second-1193", main_mod.g_cwd_display);++ const before_teardown = counter.frees;+ deinit(gpa);+ try std.testing.expect(counter.frees > before_teardown);+ // Teardown must not leave the global aliasing freed bytes.+ try std.testing.expectEqualStrings(".", main_mod.g_cwd_display);+}++test "#1193 teardown leaves a display it does not own untouched" {+ const saved = main_mod.g_cwd_display;+ defer main_mod.g_cwd_display = saved;+ adopt(std.testing.allocator, "/work/owned-1193");+ main_mod.g_cwd_display = "/work/static-1193";+ deinit(std.testing.allocator);+ try std.testing.expectEqualStrings("/work/static-1193", main_mod.g_cwd_display);+}diff --git a/src/workspace_switch.zig b/src/workspace_switch.zigindex 2e9de01f..10d2e71e 100644--- a/src/workspace_switch.zig+++ b/src/workspace_switch.zig@@ -48,19 +48,9 @@ pub const Resolve = union(enum) {ambiguous: []const Entry,};-var g_cwd_owned: ?[]u8 = null;--pub fn deinitDisplay(gpa: Allocator) void {- if (g_cwd_owned) |old| gpa.free(old);- g_cwd_owned = null;-}--fn adoptDisplay(gpa: Allocator, path: []const u8) void {- const owned = gpa.dupe(u8, path) catch return;- if (g_cwd_owned) |old| gpa.free(old);- g_cwd_owned = owned;- main_mod.g_cwd_display = owned;-}+// #1193: a replaced display is retired, not freed — see workspace_display.zig.+pub const deinitDisplay = @import("workspace_display.zig").deinit;+const adoptDisplay = @import("workspace_display.zig").adopt;fn basename(path: []const u8) []const u8 {const trimmed = std.mem.trimEnd(u8, path, "/");