fix(zig): cartridge adapter builds clean on Zig 0.15.2

The adapter at cartridges/echidna-llm-mcp/adapter/ was unbuildable on
Zig 0.15.2 — three independent issues, all addressed:

1. **adapter/build.zig** — Zig 0.15 dropped `.root_source_file` from
   `Build.ExecutableOptions`. Switched to the module-first pattern:
   create `adapter_mod` via `b.createModule(...)`, then pass it to
   `b.addExecutable(.{ .root_module = adapter_mod })`. Mirrors the
   sibling ffi/build.zig already on the new API.

2. **adapter/build.zig** — Added `.link_libc = true` to both modules
   (ffi_mod + adapter_mod). The FFI uses C allocator + libc memory
   functions; without explicit libc linkage Zig 0.15 errors out at
   `std.heap.c_allocator` and `std.c.malloc` references.

3. **ffi/echidna_llm_ffi.zig** — All 16 `export fn` declarations
   (echidna_llm_init/.../boj_cartridge_*) needed `pub` visibility too.
   Pure C-ABI export is fine for FFI consumers via the symbol table,
   but the adapter imports the FFI as a Zig module (`@import("echidna_llm_ffi")`)
   and Zig 0.15 requires `pub` for cross-module access.

4. **adapter/echidna_llm_adapter.zig:121** — `ffi.echidna_llm_init()`
   was called with zero arguments but the FFI signature takes
   `endpoint: [*:0]const u8`. The adapter never compiled even before
   the Zig version migration. Read endpoint from `BOJ_ENDPOINT` env var
   with a `http://127.0.0.1:7700` fallback (BoJ's default port).

Verification:
- `cd adapter && zig build` → exit 0, produces zig-out/bin/echidna_llm_adapter
- `cd ffi && zig build test` → exit 0

Note: the cartridge's primary surface is the Deno `mod.js` runtime;
this Zig adapter is the optional native path. Restoring its build
is what closes the audit-flagged "build.zig API drift" item.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

cartridges/echidna-llm-mcp/adapter/build.zig

@@ -9,18 +9,29 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
+    // The FFI module uses C allocator + libc memory functions, so its
+    // module needs `link_libc = true`; that propagates to consumers.
     const ffi_mod = b.createModule(.{
         .root_source_file = b.path("../ffi/echidna_llm_ffi.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
     });
 
-    const adapter = b.addExecutable(.{
-        .name = "echidna_llm_adapter",
+    // Zig 0.15 dropped `.root_source_file` from ExecutableOptions; the
+    // canonical pattern is now to build the executable's root module first
+    // and pass it via `.root_module`. Mirrors the sibling ffi/build.zig.
+    const adapter_mod = b.createModule(.{
         .root_source_file = b.path("echidna_llm_adapter.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
+    });
+    adapter_mod.addImport("echidna_llm_ffi", ffi_mod);
+
+    const adapter = b.addExecutable(.{
+        .name = "echidna_llm_adapter",
+        .root_module = adapter_mod,
     });
-    adapter.root_module.addImport("echidna_llm_ffi", ffi_mod);
     b.installArtifact(adapter);
 }

cartridges/echidna-llm-mcp/adapter/echidna_llm_adapter.zig

@@ -118,7 +118,18 @@ fn listenLoop(port: u16) !void {
 }
 
 pub fn main() !void {
-    ffi.echidna_llm_init();
+    // FFI signature is `echidna_llm_init(endpoint: [*:0]const u8)`. Read the
+    // endpoint from BOJ_ENDPOINT env var, falling back to BoJ's default port.
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+    const endpoint_z = std.process.getEnvVarOwned(allocator, "BOJ_ENDPOINT") catch
+        try allocator.dupeZ(u8, "http://127.0.0.1:7700");
+    const endpoint_cstr: [*:0]const u8 = if (@TypeOf(endpoint_z) == [:0]u8)
+        endpoint_z.ptr
+    else
+        try allocator.dupeZ(u8, endpoint_z);
+    _ = ffi.echidna_llm_init(endpoint_cstr);
     const t1 = try std.Thread.spawn(.{}, listenLoop, .{REST_PORT});
     const t2 = try std.Thread.spawn(.{}, listenLoop, .{GRPC_PORT});
     const t3 = try std.Thread.spawn(.{}, listenLoop, .{GQL_PORT});

cartridges/echidna-llm-mcp/ffi/echidna_llm_ffi.zig

@@ -89,7 +89,7 @@ var boj_endpoint_len: usize = 0;
 // ═══════════════════════════════════════════════════════════════════════
 
 /// Initialise the cartridge with BoJ endpoint URL
-export fn echidna_llm_init(endpoint: [*:0]const u8) c_int {
+pub export fn echidna_llm_init(endpoint: [*:0]const u8) c_int {
     state_mutex.lock();
     defer state_mutex.unlock();
 
@@ -107,7 +107,7 @@ export fn echidna_llm_init(endpoint: [*:0]const u8) c_int {
 
 /// Create an ephemeral session token
 /// Returns 0 on success, -1 on invalid transition
-export fn echidna_llm_authenticate(
+pub export fn echidna_llm_authenticate(
     token_ptr: [*]const u8,
     token_len: c_int,
     max_calls: c_int,
@@ -137,7 +137,7 @@ export fn echidna_llm_authenticate(
 }
 
 /// Transition to operating state
-export fn echidna_llm_start_operating() c_int {
+pub export fn echidna_llm_start_operating() c_int {
     state_mutex.lock();
     defer state_mutex.unlock();
 
@@ -147,7 +147,7 @@ export fn echidna_llm_start_operating() c_int {
 }
 
 /// Close the session (from authenticated or operating)
-export fn echidna_llm_close() c_int {
+pub export fn echidna_llm_close() c_int {
     state_mutex.lock();
     defer state_mutex.unlock();
 
@@ -160,14 +160,14 @@ export fn echidna_llm_close() c_int {
 }
 
 /// Get current session state
-export fn echidna_llm_get_state() c_int {
+pub export fn echidna_llm_get_state() c_int {
     state_mutex.lock();
     defer state_mutex.unlock();
     return @intFromEnum(current_session.state);
 }
 
 /// Check if the session is still valid (not expired, not over call limit)
-export fn echidna_llm_session_valid() c_int {
+pub export fn echidna_llm_session_valid() c_int {
     state_mutex.lock();
     defer state_mutex.unlock();
 
@@ -199,7 +199,7 @@ export fn echidna_llm_session_valid() c_int {
 ///   model:                   Model tier (0=haiku, 1=sonnet, 2=opus)
 ///
 /// Returns: null-terminated JSON string, or NULL on error
-export fn echidna_llm_suggest_tactics(
+pub export fn echidna_llm_suggest_tactics(
     goal_ptr: [*]const u8,
     goal_len: c_int,
     hypotheses_ptr: [*]const u8,
@@ -259,7 +259,7 @@ export fn echidna_llm_suggest_tactics(
 }
 
 /// Rank provers for a goal. Returns heap-allocated JSON. Caller MUST free.
-export fn echidna_llm_rank_provers(
+pub export fn echidna_llm_rank_provers(
     goal_ptr: [*]const u8,
     goal_len: c_int,
     model: c_int,
@@ -286,7 +286,7 @@ export fn echidna_llm_rank_provers(
 // ═══════════════════════════════════════════════════════════════════════
 
 /// Free a string returned by any echidna_llm_* function
-export fn echidna_llm_free(ptr: ?[*:0]u8) void {
+pub export fn echidna_llm_free(ptr: ?[*:0]u8) void {
     const p = ptr orelse return;
     const allocator = std.heap.c_allocator;
     const slice = std.mem.span(p);
@@ -299,7 +299,7 @@ export fn echidna_llm_free(ptr: ?[*:0]u8) void {
 
 /// Check if a state transition is valid (C ABI)
 /// Mirrors llm_can_transition from Protocol.idr
-export fn echidna_llm_can_transition(from: c_int, to: c_int) c_int {
+pub export fn echidna_llm_can_transition(from: c_int, to: c_int) c_int {
     return switch (from) {
         0 => if (to == 1) @as(c_int, 1) else 0, // Unauth → Auth
         1 => if (to == 2 or to == 3) @as(c_int, 1) else 0, // Auth → Op or Closed
@@ -309,7 +309,7 @@ export fn echidna_llm_can_transition(from: c_int, to: c_int) c_int {
 }
 
 /// Check if an operation is advisory (always 1, proven in Idris2)
-export fn echidna_llm_is_advisory(op: c_int) c_int {
+pub export fn echidna_llm_is_advisory(op: c_int) c_int {
     _ = op;
     return 1; // All operations advisory, by construction
 }
@@ -323,22 +323,22 @@ const shim = @import("cartridge_shim.zig");
 const CARTRIDGE_NAME_PTR: [*:0]const u8 = "echidna-llm-mcp";
 const CARTRIDGE_VERSION_PTR: [*:0]const u8 = "0.1.0";
 
-export fn boj_cartridge_init() callconv(.c) c_int {
+pub export fn boj_cartridge_init() callconv(.c) c_int {
     return 0;
 }
 
-export fn boj_cartridge_deinit() callconv(.c) void {}
+pub export fn boj_cartridge_deinit() callconv(.c) void {}
 
-export fn boj_cartridge_name() callconv(.c) [*:0]const u8 {
+pub export fn boj_cartridge_name() callconv(.c) [*:0]const u8 {
     return CARTRIDGE_NAME_PTR;
 }
 
-export fn boj_cartridge_version() callconv(.c) [*:0]const u8 {
+pub export fn boj_cartridge_version() callconv(.c) [*:0]const u8 {
     return CARTRIDGE_VERSION_PTR;
 }
 
 /// Dispatch the 4 cartridge.json MCP tools. Grade D Alpha stubs.
-export fn boj_cartridge_invoke(
+pub export fn boj_cartridge_invoke(
     tool_name: [*c]const u8,
     json_args: [*c]const u8,
     out_buf: [*c]u8,