Bump v0.0.27: SIGINT partial telemetry on early exit (#385)

* Bump v0.0.27: SIGINT handler sends partial telemetry on early exit

Catches Ctrl+C during swarm runs and sends partial telemetry if at least
one worker completed — skips entirely if zero agents finished (bad data).
Adds `"interrupted":true` field to telemetry JSON for interrupted runs.

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

* Bump npm/package.json to 0.0.27 for version consistency

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

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: justrach

build.zig

@@ -5,7 +5,7 @@ pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     // Version: defaults to build.zig.zon value; override with -Dversion=X.Y.Z at release
-    const version = b.option([]const u8, "version", "Version string") orelse "0.0.26";
+    const version = b.option([]const u8, "version", "Version string") orelse "0.0.27";
     const build_options = b.addOptions();
     build_options.addOption([]const u8, "version", version);
 

build.zig.zon

@@ -9,7 +9,7 @@
     .name = .codedb,
     // This is a [Semantic Version](https://semver.org/).
     // In a future version of Zig it will be used for package deduplication.
-    .version = "0.0.26",
+    .version = "0.0.27",
     // Together with name, this represents a globally unique package
     // identifier. This field is generated by the Zig toolchain when the
     // package is first created, and then *never changes*. This allows

npm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devswarm",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "description": "Orchestrate AI coding agents (Claude Code, Codex, Gemini CLI) with GitHub ops, swarm spawning, and code graph intelligence — over MCP",
   "keywords": ["mcp", "github", "ai", "claude", "codex", "swarm", "agents", "orchestration"],
   "homepage": "https://github.com/justrach/codedb",

src/swarm.zig

@@ -20,6 +20,30 @@ const notify = @import("notify.zig");
 /// Hard ceiling on parallel agents regardless of what the caller requests.
 pub const HARD_MAX: u32 = 100;
 
+// ── SIGINT handling for partial telemetry ──────────────────────────────────────
+var g_interrupted: std.atomic.Value(bool) = std.atomic.Value(bool).init(false);
+
+fn sigintHandler(_: c_int) callconv(.c) void {
+    g_interrupted.store(true, .release);
+}
+
+fn installSigintHandler() void {
+    const act = std.posix.Sigaction{
+        .handler = .{ .handler = sigintHandler },
+        .mask = std.posix.sigemptyset(),
+        .flags = 0,
+    };
+    std.posix.sigaction(std.posix.SIG.INT, &act, null);
+}
+
+fn restoreDefaultSigint() void {
+    const act = std.posix.Sigaction{
+        .handler = .{ .handler = null },
+        .mask = std.posix.sigemptyset(),
+        .flags = 0,
+    };
+    std.posix.sigaction(std.posix.SIG.INT, &act, null);
+}
 // ── Worker ────────────────────────────────────────────────────────────────────
 
 const Worker = struct {
@@ -134,6 +158,10 @@ pub fn runSwarm(
 ) void {
     const cap: usize = @min(max_agents, HARD_MAX);
 
+    // ── Install SIGINT handler for partial telemetry ──────────────────────────
+    g_interrupted.store(false, .release);
+    installSigintHandler();
+    defer restoreDefaultSigint();
     // ── Phase 0: Announce swarm start ────────────────────────────────────────
     {
         var msg_buf: [256]u8 = undefined;
@@ -323,7 +351,58 @@ pub fn runSwarm(
         if (w.allocated_prompt) |p| alloc.free(p);
     }
 
-    // ── Phase 3b: Capture file manifest for writable swarms ──────────────
+    // ── Check for early interruption ─────────────────────────────────────────
+    if (g_interrupted.load(.acquire)) {
+        // Count how many workers actually completed successfully
+        var completed: usize = 0;
+        for (worker_metrics[0..count]) |m| {
+            if (m.success) completed += 1;
+        }
+
+        if (completed > 0) {
+            // Send partial telemetry — at least one agent finished
+            var grid = telemetry.GridMetrics.init(alloc, "worker");
+            for (worker_metrics[0..count]) |*m| {
+                m.*.role = workers[m.worker_id].role;
+                m.*.model = workers[m.worker_id].model;
+                grid.addWorker(alloc, m.*) catch {};
+            }
+            swarm_telemetry.addGrid(grid) catch {};
+
+            const telemetry_json = swarm_telemetry.toJson(alloc, true);
+            if (telemetry_json.len > 0) {
+                std.debug.print("\n[telemetry:interrupted] {d}/{d} agents completed\n", .{ completed, count });
+                std.debug.print("[telemetry] {s}\n", .{telemetry_json});
+                telemetry.upload(alloc, telemetry_json);
+
+                if (telemetry_out) |path| {
+                    const file = if (std.fs.path.isAbsolute(path))
+                        std.fs.createFileAbsolute(path, .{}) catch null
+                    else
+                        std.fs.cwd().createFile(path, .{}) catch null;
+                    if (file) |f| {
+                        defer f.close();
+                        f.writeAll(telemetry_json) catch {};
+                        f.writeAll("\n") catch {};
+                    }
+                }
+                alloc.free(telemetry_json);
+            }
+        } else {
+            std.debug.print("\n[telemetry:interrupted] no agents completed — skipping telemetry\n", .{});
+        }
+
+        // Write partial results to output
+        for (workers[0..count]) |*w| {
+            if (w.out.items.len > 0) {
+                out.appendSlice(alloc, w.out.items) catch {};
+                out.appendSlice(alloc, "\n") catch {};
+            }
+            w.out.deinit(std.heap.page_allocator);
+        }
+        appendErr(alloc, out, "swarm interrupted by user (Ctrl+C)");
+        return;
+    }
     var manifest: []const u8 = "";
     var manifest_alloc: ?[]u8 = null;
     defer if (manifest_alloc) |m| alloc.free(m);
@@ -397,7 +476,7 @@ pub fn runSwarm(
     swarm_telemetry.addGrid(grid) catch {};
 
 
-    const telemetry_json = swarm_telemetry.toJson(alloc);
+    const telemetry_json = swarm_telemetry.toJson(alloc, false);
     if (telemetry_json.len > 0) {
         std.debug.print("\n[telemetry] {s}\n", .{telemetry_json});
 
@@ -461,4 +540,42 @@ test "swarm: appendErr writes JSON error object" {
     try std.testing.expect(parsed.value == .object);
     const msg = parsed.value.object.get("error") orelse return error.MissingError;
     try std.testing.expectEqualStrings("something went wrong", msg.string);
+    try std.testing.expectEqualStrings("something went wrong", msg.string);
+}
+
+test "swarm: g_interrupted starts false" {
+    try std.testing.expect(!g_interrupted.load(.acquire));
+}
+
+test "swarm: sigint handler sets interrupted flag" {
+    // Reset to known state
+    g_interrupted.store(false, .release);
+    try std.testing.expect(!g_interrupted.load(.acquire));
+
+    // Simulate what the signal handler does
+    sigintHandler(0);
+
+    try std.testing.expect(g_interrupted.load(.acquire));
+
+    // Reset
+    g_interrupted.store(false, .release);
+}
+
+test "swarm: install and restore sigint handler" {
+    // Should not crash
+    installSigintHandler();
+    restoreDefaultSigint();
+}
+
+test "swarm: sigint handler is idempotent" {
+    g_interrupted.store(false, .release);
+
+    // Multiple signals should not cause issues
+    sigintHandler(0);
+    sigintHandler(0);
+    sigintHandler(0);
+
+    try std.testing.expect(g_interrupted.load(.acquire));
+
+    g_interrupted.store(false, .release);
 }

src/telemetry.zig

@@ -178,7 +178,7 @@ pub const SwarmTelemetry = struct {
         }
     }
 
-    pub fn toJson(self: *Self, alloc: std.mem.Allocator) []const u8 {
+    pub fn toJson(self: *Self, alloc: std.mem.Allocator, interrupted: bool) []const u8 {
         self.finalize();
 
         var buf: std.ArrayList(u8) = .empty;
@@ -223,6 +223,10 @@ pub const SwarmTelemetry = struct {
         const pt_str = std.fmt.bufPrint(&ms_buf, "{d}", .{self.parallelism_theoretical}) catch "";
         buf.appendSlice(alloc, pt_str) catch return "";
 
+        if (interrupted) {
+            buf.appendSlice(alloc, ",\"interrupted\":true") catch return "";
+        }
+
         buf.appendSlice(alloc, "}") catch return "";
 
         return alloc.dupe(u8, buf.items) catch "";
@@ -443,7 +447,7 @@ test "telemetry: SwarmTelemetry toJson produces valid JSON" {
     t.parallelism_theoretical = 4;
 
 
-    const json = t.toJson(alloc);
+    const json = t.toJson(alloc, false);
     defer alloc.free(json);
 
     const parsed = try std.json.parseFromSlice(std.json.Value, alloc, json, .{});
@@ -456,6 +460,104 @@ test "telemetry: SwarmTelemetry toJson produces valid JSON" {
     try std.testing.expect(obj.get("grids") != null);
     try std.testing.expect(obj.get("total_cost_usd") != null);
     try std.testing.expect(obj.get("total_wall_ms") != null);
+    try std.testing.expect(obj.get("total_wall_ms") != null);
+    // Non-interrupted should NOT have "interrupted" field
+    try std.testing.expect(obj.get("interrupted") == null);
+}
+
+test "telemetry: toJson with interrupted=true includes interrupted field" {
+    const alloc = std.testing.allocator;
+    var t = SwarmTelemetry.init(alloc, "interrupted task");
+    defer t.deinit();
+
+    var grid = GridMetrics.init(alloc, "worker");
+    var w = WorkerMetrics.init(0, "finder", "claude-sonnet-4-6");
+    w.tokens_in = 1000;
+    w.tokens_out = 500;
+    w.wall_ms = 2000;
+    w.success = true;
+    try grid.addWorker(alloc, w);
+    try t.addGrid(grid);
+
+    const json = t.toJson(alloc, true);
+    defer alloc.free(json);
+
+    const parsed = try std.json.parseFromSlice(std.json.Value, alloc, json, .{});
+    defer parsed.deinit();
+
+    const obj = &parsed.value.object;
+    try std.testing.expect(obj.get("interrupted") != null);
+    try std.testing.expect(obj.get("interrupted").?.bool == true);
+    try std.testing.expectEqualStrings("interrupted task", obj.get("task").?.string);
+}
+
+test "telemetry: toJson with interrupted=false omits interrupted field" {
+    const alloc = std.testing.allocator;
+    var t = SwarmTelemetry.init(alloc, "normal task");
+    defer t.deinit();
+
+    const json = t.toJson(alloc, false);
+    defer alloc.free(json);
+
+    const parsed = try std.json.parseFromSlice(std.json.Value, alloc, json, .{});
+    defer parsed.deinit();
+
+    const obj = &parsed.value.object;
+    try std.testing.expect(obj.get("interrupted") == null);
+}
+
+test "telemetry: partial telemetry with mixed worker success" {
+    const alloc = std.testing.allocator;
+    var t = SwarmTelemetry.init(alloc, "partial swarm");
+    defer t.deinit();
+
+    var grid = GridMetrics.init(alloc, "worker");
+
+    // Worker 0: completed successfully
+    var w0 = WorkerMetrics.init(0, "finder", "claude-sonnet-4-6");
+    w0.tokens_in = 3000;
+    w0.tokens_out = 1200;
+    w0.wall_ms = 5000;
+    w0.tool_calls = 8;
+    w0.success = true;
+    try grid.addWorker(alloc, w0);
+
+    // Worker 1: interrupted mid-run (no output)
+    var w1 = WorkerMetrics.init(1, "reviewer", "claude-sonnet-4-6");
+    w1.tokens_in = 500;
+    w1.tokens_out = 0;
+    w1.wall_ms = 1200;
+    w1.success = false;
+    try grid.addWorker(alloc, w1);
+
+    // Worker 2: completed successfully
+    var w2 = WorkerMetrics.init(2, "fixer", "claude-sonnet-4-6");
+    w2.tokens_in = 2000;
+    w2.tokens_out = 800;
+    w2.wall_ms = 4000;
+    w2.tool_calls = 5;
+    w2.success = true;
+    try grid.addWorker(alloc, w2);
+
+    try t.addGrid(grid);
+
+    const json = t.toJson(alloc, true);
+    defer alloc.free(json);
+
+    const parsed = try std.json.parseFromSlice(std.json.Value, alloc, json, .{});
+    defer parsed.deinit();
+
+    const obj = &parsed.value.object;
+    try std.testing.expect(obj.get("interrupted").?.bool == true);
+
+    // Should have all 3 workers in the grid (including the failed one)
+    const grids = obj.get("grids").?.array;
+    try std.testing.expectEqual(@as(usize, 1), grids.items.len);
+    const workers = grids.items[0].object.get("workers").?.array;
+    try std.testing.expectEqual(@as(usize, 3), workers.items.len);
+
+    // Cost should still be calculated for workers that ran
+    try std.testing.expect(obj.get("total_cost_usd").?.float > 0);
 }
 
 test "telemetry: estimateCost returns expected values" {