feat(adr-0006): migrate 5 cartridges to 5-symbol ABI (Pattern B batch 2)

Pattern B migration (buildkite-mcp,burble-admin-mcp,circleci-mcp,civic-connect-mcp,claude-ai-mcp). All 5 ADR-0005+0006 exports added;
boj_cartridge_invoke dispatches cartridge.json tools to Grade-D-Alpha
stub bodies via cartridge_shim. Tests passing per cartridge.

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

Author: hyperpolymath

cartridges/buildkite-mcp/ffi/build.zig

@@ -7,12 +7,26 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
+    // Shared ADR-0006 invoke-shim module (relative path up to boj-server trunk).
+
+    const shim_mod = b.addModule("cartridge_shim", .{
+
+        .root_source_file = b.path("../../../ffi/zig/src/cartridge_shim.zig"),
+
+        .target = target,
+
+        .optimize = optimize,
+
+    });
+
     const ffi_mod = b.addModule("buildkite_mcp", .{
         .root_source_file = b.path("buildkite_mcp_ffi.zig"),
         .target = target,
         .optimize = optimize,
     });
 
+    ffi_mod.addImport("cartridge_shim", shim_mod);
+
     const lib = b.addLibrary(.{
         .name = "buildkite_mcp",
         .root_module = ffi_mod,

cartridges/buildkite-mcp/ffi/buildkite_mcp_ffi.zig

@@ -220,6 +220,65 @@ pub export fn buildkite_mcp_reset() void {
     sessions = .{SessionSlot{}} ** MAX_SESSIONS;
 }
 
+// ═══════════════════════════════════════════════════════════════════════
+// Standard ABI (ADR-0005 four symbols + ADR-0006 invoke)
+// ═══════════════════════════════════════════════════════════════════════
+
+const shim = @import("cartridge_shim");
+
+const CARTRIDGE_NAME_PTR: [*:0]const u8 = "buildkite-mcp";
+const CARTRIDGE_VERSION_PTR: [*:0]const u8 = "0.1.0";
+
+export fn boj_cartridge_init() callconv(.c) c_int {
+    return 0;
+}
+
+export fn boj_cartridge_deinit() callconv(.c) void {}
+
+export fn boj_cartridge_name() callconv(.c) [*:0]const u8 {
+    return CARTRIDGE_NAME_PTR;
+}
+
+export fn boj_cartridge_version() callconv(.c) [*:0]const u8 {
+    return CARTRIDGE_VERSION_PTR;
+}
+
+/// Dispatch the cartridge.json MCP tools. Grade D Alpha stubs.
+export fn boj_cartridge_invoke(
+    tool_name: [*c]const u8,
+    json_args: [*c]const u8,
+    out_buf: [*c]u8,
+    in_out_len: [*c]usize,
+) callconv(.c) i32 {
+    _ = json_args;
+    if (shim.invokeArgsNull(tool_name, out_buf, in_out_len)) return shim.RC_BAD_ARGS;
+
+    const body: []const u8 =     if (shim.toolIs(tool_name, "buildkite_list_pipelines"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "buildkite_get_pipeline"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "buildkite_list_builds"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "buildkite_get_build"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "buildkite_create_build"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "buildkite_cancel_build"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "buildkite_list_jobs"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "buildkite_get_job_log"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "buildkite_list_artifacts"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "buildkite_list_agents"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+else
+    return shim.RC_UNKNOWN_TOOL;
+
+    return shim.writeResult(out_buf, in_out_len, body);
+}
+
 test "authenticated session lifecycle" {
     buildkite_mcp_reset();
     const slot = buildkite_mcp_authenticate(0);
@@ -270,3 +329,53 @@ test "slot exhaustion" {
     try std.testing.expectEqual(@as(c_int, 0), buildkite_mcp_close(slots[0]));
     try std.testing.expect(buildkite_mcp_authenticate(0) >= 0);
 }
+
+// ═══════════════════════════════════════════════════════════════════════
+// ADR-0006 invoke dispatch tests
+// ═══════════════════════════════════════════════════════════════════════
+
+test "boj_cartridge_name returns buildkite-mcp" {
+    const n = std.mem.span(boj_cartridge_name());
+    try std.testing.expectEqualStrings("buildkite-mcp", n);
+}
+
+test "boj_cartridge_init returns 0" {
+    try std.testing.expectEqual(@as(c_int, 0), boj_cartridge_init());
+}
+
+test "invoke: each declared tool succeeds" {
+    var buf: [256]u8 = undefined;
+    const tools = [_][]const u8{
+        "buildkite_list_pipelines",
+        "buildkite_get_pipeline",
+        "buildkite_list_builds",
+        "buildkite_get_build",
+        "buildkite_create_build",
+        "buildkite_cancel_build",
+        "buildkite_list_jobs",
+        "buildkite_get_job_log",
+        "buildkite_list_artifacts",
+        "buildkite_list_agents",
+    };
+    for (tools) |t| {
+        var len: usize = buf.len;
+        const rc = boj_cartridge_invoke(t.ptr, "{}", &buf, &len);
+        try std.testing.expectEqual(@as(i32, 0), rc);
+        try std.testing.expect(std.mem.indexOf(u8, buf[0..len], "result") != null);
+    }
+}
+
+test "invoke: unknown tool returns -1" {
+    var buf: [64]u8 = undefined;
+    var len: usize = buf.len;
+    const rc = boj_cartridge_invoke("nope", "{}", &buf, &len);
+    try std.testing.expectEqual(@as(i32, -1), rc);
+}
+
+test "invoke: buffer too small returns -3" {
+    var buf: [4]u8 = undefined;
+    var len: usize = buf.len;
+    const rc = boj_cartridge_invoke("buildkite_list_pipelines", "{}", &buf, &len);
+    try std.testing.expectEqual(@as(i32, -3), rc);
+    try std.testing.expect(len > 4);
+}

cartridges/burble-admin-mcp/ffi/build.zig

@@ -5,11 +5,25 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
+    // Shared ADR-0006 invoke-shim module (relative path up to boj-server trunk).
+
+    const shim_mod = b.addModule("cartridge_shim", .{
+
+        .root_source_file = b.path("../../../ffi/zig/src/cartridge_shim.zig"),
+
+        .target = target,
+
+        .optimize = optimize,
+
+    });
+
     const ffi_mod = b.addModule("burble_admin_ffi", .{
         .root_source_file = b.path("burble_admin_ffi.zig"),
         .target = target,
         .optimize = optimize,
     });
+
+    ffi_mod.addImport("cartridge_shim", shim_mod);
     const lib = b.addLibrary(.{
         .name = "burble_admin_ffi",
         .root_module = ffi_mod,

cartridges/burble-admin-mcp/ffi/burble_admin_ffi.zig

@@ -62,6 +62,65 @@ pub export fn burble_admin_clamp_capacity(requested: i32) i32 {
     return requested;
 }
 
+// ═══════════════════════════════════════════════════════════════════════
+// Standard ABI (ADR-0005 four symbols + ADR-0006 invoke)
+// ═══════════════════════════════════════════════════════════════════════
+
+const shim = @import("cartridge_shim");
+
+const CARTRIDGE_NAME_PTR: [*:0]const u8 = "burble-admin-mcp";
+const CARTRIDGE_VERSION_PTR: [*:0]const u8 = "0.1.0";
+
+export fn boj_cartridge_init() callconv(.c) c_int {
+    return 0;
+}
+
+export fn boj_cartridge_deinit() callconv(.c) void {}
+
+export fn boj_cartridge_name() callconv(.c) [*:0]const u8 {
+    return CARTRIDGE_NAME_PTR;
+}
+
+export fn boj_cartridge_version() callconv(.c) [*:0]const u8 {
+    return CARTRIDGE_VERSION_PTR;
+}
+
+/// Dispatch the cartridge.json MCP tools. Grade D Alpha stubs.
+export fn boj_cartridge_invoke(
+    tool_name: [*c]const u8,
+    json_args: [*c]const u8,
+    out_buf: [*c]u8,
+    in_out_len: [*c]usize,
+) callconv(.c) i32 {
+    _ = json_args;
+    if (shim.invokeArgsNull(tool_name, out_buf, in_out_len)) return shim.RC_BAD_ARGS;
+
+    const body: []const u8 =     if (shim.toolIs(tool_name, "burble_check_health"))
+        "{\"result\":{\"health\":\"healthy\",\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "burble_list_rooms"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "burble_create_room"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "burble_close_room"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "burble_kick_user"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "burble_get_config"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "burble_update_config"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "burble_voice_stats"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "burble_toggle_recording"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "burble_node_status"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+else
+    return shim.RC_UNKNOWN_TOOL;
+
+    return shim.writeResult(out_buf, in_out_len, body);
+}
+
 // ═══════════════════════════════════════════════════════════════════════
 // Tests
 // ═══════════════════════════════════════════════════════════════════════
@@ -95,3 +154,53 @@ test "capacity clamping" {
     try std.testing.expectEqual(@as(i32, 50), burble_admin_clamp_capacity(50));
     try std.testing.expectEqual(@as(i32, 500), burble_admin_clamp_capacity(999));
 }
+
+// ═══════════════════════════════════════════════════════════════════════
+// ADR-0006 invoke dispatch tests
+// ═══════════════════════════════════════════════════════════════════════
+
+test "boj_cartridge_name returns burble-admin-mcp" {
+    const n = std.mem.span(boj_cartridge_name());
+    try std.testing.expectEqualStrings("burble-admin-mcp", n);
+}
+
+test "boj_cartridge_init returns 0" {
+    try std.testing.expectEqual(@as(c_int, 0), boj_cartridge_init());
+}
+
+test "invoke: each declared tool succeeds" {
+    var buf: [256]u8 = undefined;
+    const tools = [_][]const u8{
+        "burble_check_health",
+        "burble_list_rooms",
+        "burble_create_room",
+        "burble_close_room",
+        "burble_kick_user",
+        "burble_get_config",
+        "burble_update_config",
+        "burble_voice_stats",
+        "burble_toggle_recording",
+        "burble_node_status",
+    };
+    for (tools) |t| {
+        var len: usize = buf.len;
+        const rc = boj_cartridge_invoke(t.ptr, "{}", &buf, &len);
+        try std.testing.expectEqual(@as(i32, 0), rc);
+        try std.testing.expect(std.mem.indexOf(u8, buf[0..len], "result") != null);
+    }
+}
+
+test "invoke: unknown tool returns -1" {
+    var buf: [64]u8 = undefined;
+    var len: usize = buf.len;
+    const rc = boj_cartridge_invoke("nope", "{}", &buf, &len);
+    try std.testing.expectEqual(@as(i32, -1), rc);
+}
+
+test "invoke: buffer too small returns -3" {
+    var buf: [4]u8 = undefined;
+    var len: usize = buf.len;
+    const rc = boj_cartridge_invoke("burble_check_health", "{}", &buf, &len);
+    try std.testing.expectEqual(@as(i32, -3), rc);
+    try std.testing.expect(len > 4);
+}

cartridges/circleci-mcp/ffi/build.zig

@@ -7,12 +7,26 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
+    // Shared ADR-0006 invoke-shim module (relative path up to boj-server trunk).
+
+    const shim_mod = b.addModule("cartridge_shim", .{
+
+        .root_source_file = b.path("../../../ffi/zig/src/cartridge_shim.zig"),
+
+        .target = target,
+
+        .optimize = optimize,
+
+    });
+
     const ffi_mod = b.addModule("circleci_mcp", .{
         .root_source_file = b.path("circleci_mcp_ffi.zig"),
         .target = target,
         .optimize = optimize,
     });
 
+    ffi_mod.addImport("cartridge_shim", shim_mod);
+
     const lib = b.addLibrary(.{
         .name = "circleci_mcp",
         .root_module = ffi_mod,