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

Pattern B migration (hackage-mcp,hetzner-mcp,hex-mcp,idaptik-admin-mcp,jira-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/hackage-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("hackage_mcp", .{
         .root_source_file = b.path("hackage_mcp_ffi.zig"),
         .target = target,
         .optimize = optimize,
     });
 
+    ffi_mod.addImport("cartridge_shim", shim_mod);
+
     const lib = b.addLibrary(.{
         .name = "hackage_mcp",
         .root_module = ffi_mod,

cartridges/hackage-mcp/ffi/hackage_mcp_ffi.zig

@@ -304,6 +304,69 @@ pub export fn hackage_mcp_reset() void {
 }
 
 // ---------------------------------------------------------------------------
+// ═══════════════════════════════════════════════════════════════════════
+// Standard ABI (ADR-0005 four symbols + ADR-0006 invoke)
+// ═══════════════════════════════════════════════════════════════════════
+
+const shim = @import("cartridge_shim");
+
+const CARTRIDGE_NAME_PTR: [*:0]const u8 = "hackage-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, "hackage_search_packages"))
+        "{\"result\":{\"matches\":[],\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_get_package"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_get_version"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_list_versions"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_get_downloads"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_get_dependencies"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_get_reverse_dependencies"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_get_maintainers"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_get_deprecated"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_get_cabal_file"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_list_all_packages"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hackage_get_user"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+else
+    return shim.RC_UNKNOWN_TOOL;
+
+    return shim.writeResult(out_buf, in_out_len, body);
+}
+
 // Tests
 // ---------------------------------------------------------------------------
 
@@ -403,3 +466,55 @@ test "slot exhaustion" {
     const new_slot = hackage_mcp_authenticate(0);
     try std.testing.expect(new_slot >= 0);
 }
+
+// ═══════════════════════════════════════════════════════════════════════
+// ADR-0006 invoke dispatch tests
+// ═══════════════════════════════════════════════════════════════════════
+
+test "boj_cartridge_name returns hackage-mcp" {
+    const n = std.mem.span(boj_cartridge_name());
+    try std.testing.expectEqualStrings("hackage-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{
+        "hackage_search_packages",
+        "hackage_get_package",
+        "hackage_get_version",
+        "hackage_list_versions",
+        "hackage_get_downloads",
+        "hackage_get_dependencies",
+        "hackage_get_reverse_dependencies",
+        "hackage_get_maintainers",
+        "hackage_get_deprecated",
+        "hackage_get_cabal_file",
+        "hackage_list_all_packages",
+        "hackage_get_user",
+    };
+    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("hackage_search_packages", "{}", &buf, &len);
+    try std.testing.expectEqual(@as(i32, -3), rc);
+    try std.testing.expect(len > 4);
+}

cartridges/hetzner-mcp/ffi/build.zig

@@ -10,12 +10,26 @@ pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     // Module
+    // 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("hetzner_mcp", .{
         .root_source_file = b.path("hetzner_mcp_ffi.zig"),
         .target = target,
         .optimize = optimize,
     });
 
+    ffi_mod.addImport("cartridge_shim", shim_mod);
+
     // Shared library
     const lib = b.addLibrary(.{
         .name = "hetzner_mcp",

cartridges/hetzner-mcp/ffi/hetzner_mcp_ffi.zig

@@ -324,6 +324,85 @@ pub export fn hetzner_mcp_reset() void {
 }
 
 // ---------------------------------------------------------------------------
+// ═══════════════════════════════════════════════════════════════════════
+// Standard ABI (ADR-0005 four symbols + ADR-0006 invoke)
+// ═══════════════════════════════════════════════════════════════════════
+
+const shim = @import("cartridge_shim");
+
+const CARTRIDGE_NAME_PTR: [*:0]const u8 = "hetzner-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, "hetzner_list_servers"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_get_server"))
+        "{\"result\":{\"metadata\":{},\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_create_server"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_delete_server"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_server_action"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_resize_server"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_list_floating_ips"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_create_floating_ip"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_list_volumes"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_create_volume"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_list_firewalls"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_create_firewall"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_list_ssh_keys"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_create_ssh_key"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_list_images"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_create_snapshot"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_list_networks"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_create_network"))
+        "{\"result\":{\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_list_load_balancers"))
+        "{\"result\":{\"items\":[],\"count\":0,\"status\":\"stub\"}}"
+    else if (shim.toolIs(tool_name, "hetzner_create_load_balancer"))
+        "{\"result\":{\"status\":\"stub\"}}"
+else
+    return shim.RC_UNKNOWN_TOOL;
+
+    return shim.writeResult(out_buf, in_out_len, body);
+}
+
 // Tests
 // ---------------------------------------------------------------------------
 
@@ -443,3 +522,63 @@ test "slot exhaustion" {
     const new_slot = hetzner_mcp_authenticate(3600);
     try std.testing.expect(new_slot >= 0);
 }
+
+// ═══════════════════════════════════════════════════════════════════════
+// ADR-0006 invoke dispatch tests
+// ═══════════════════════════════════════════════════════════════════════
+
+test "boj_cartridge_name returns hetzner-mcp" {
+    const n = std.mem.span(boj_cartridge_name());
+    try std.testing.expectEqualStrings("hetzner-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{
+        "hetzner_list_servers",
+        "hetzner_get_server",
+        "hetzner_create_server",
+        "hetzner_delete_server",
+        "hetzner_server_action",
+        "hetzner_resize_server",
+        "hetzner_list_floating_ips",
+        "hetzner_create_floating_ip",
+        "hetzner_list_volumes",
+        "hetzner_create_volume",
+        "hetzner_list_firewalls",
+        "hetzner_create_firewall",
+        "hetzner_list_ssh_keys",
+        "hetzner_create_ssh_key",
+        "hetzner_list_images",
+        "hetzner_create_snapshot",
+        "hetzner_list_networks",
+        "hetzner_create_network",
+        "hetzner_list_load_balancers",
+        "hetzner_create_load_balancer",
+    };
+    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("hetzner_list_servers", "{}", &buf, &len);
+    try std.testing.expectEqual(@as(i32, -3), rc);
+    try std.testing.expect(len > 4);
+}

cartridges/hex-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("hex_mcp", .{
         .root_source_file = b.path("hex_mcp_ffi.zig"),
         .target = target,
         .optimize = optimize,
     });
 
+    ffi_mod.addImport("cartridge_shim", shim_mod);
+
     const lib = b.addLibrary(.{
         .name = "hex_mcp",
         .root_module = ffi_mod,