Skip to content

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.zig
index 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.zig
new file mode 100644
index 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.zig
index 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.zig
new file mode 100644
index 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.zig
index 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, "/");