Claude/resume repos migration 9 o2 u1 (#30)

<!-- SPDX-License-Identifier: PMPL-1.0-or-later -->
## Summary

<!-- Briefly describe what this PR does and why. Link to related issues
with "Closes #N". -->

## Changes

<!-- List the key changes introduced by this PR. -->

-

## RSR Quality Checklist

<!-- Check all that apply. PRs that fail required checks will not be
merged. -->

### Required

- [ ] Tests pass (`just test` or equivalent)
- [ ] Code is formatted (`just fmt` or equivalent)
- [ ] Linter is clean (no new warnings or errors)
- [ ] No banned language patterns (no TypeScript, no npm/bun, no
Go/Python)
- [ ] No `unsafe` blocks without `// SAFETY:` comments
- [ ] No banned functions (`believe_me`, `unsafeCoerce`, `Obj.magic`,
`Admitted`, `sorry`)
- [ ] SPDX license headers present on all new/modified source files
- [ ] No secrets, credentials, or `.env` files included

### As Applicable

- [ ] `.machine_readable/STATE.a2ml` updated (if project state changed)
- [ ] `.machine_readable/ECOSYSTEM.a2ml` updated (if integrations
changed)
- [ ] `.machine_readable/META.a2ml` updated (if architectural decisions
changed)
- [ ] Documentation updated for user-facing changes
- [ ] `TOPOLOGY.md` updated (if architecture changed)
- [ ] `CHANGELOG` or release notes updated
- [ ] New dependencies reviewed for license compatibility
(PMPL-1.0-or-later / MPL-2.0)
- [ ] ABI/FFI changes validated (`src/abi/` and `ffi/zig/` consistent)

## Testing

<!-- Describe how you tested these changes. -->

## Screenshots

<!-- If applicable, add screenshots or terminal output demonstrating the
change. -->

---------

Signed-off-by: Jonathan D.A. Jewell <6759885+hyperpolymath@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

cartridges/local-coord-mcp/adapter/local_coord_adapter.zig

@@ -818,6 +818,86 @@ fn dispatch(tool: []const u8, body: []const u8, resp: []u8, allocator: std.mem.A
         return .{ .status = 200, .body = resp[0..stream.pos] };
     }
 
+    if (std.mem.eql(u8, tool, "coord_health")) {
+        const parsed = std.json.parseFromSlice(std.json.Value, allocator, body, .{}) catch return .{ .status = 400, .body = errJson(resp, "invalid json") };
+        defer parsed.deinit();
+        const token_val = parsed.value.object.get("token") orelse return .{ .status = 400, .body = errJson(resp, "missing token") };
+        var token: [16]u8 = undefined;
+        if (!parseToken(token_val.string, &token)) return .{ .status = 400, .body = errJson(resp, "invalid token hex") };
+
+        // Gather per-peer counts by scanning the 16 slots directly.
+        var peer_active: u8 = 0;
+        var by_kind = [_]u8{ 0, 0, 0, 0, 0, 0 }; // claude/gemini/copilot/custom/openai/mistral
+        var by_role = [_]u8{ 0, 0, 0 }; // master / journeyman / apprentice
+        var i: c_int = 0;
+        while (i < 16) : (i += 1) {
+            const k = ffi.coord_read_peer_kind(i);
+            if (k < 0) continue;
+            peer_active += 1;
+            if (k >= 0 and k < 6) by_kind[@intCast(k)] += 1;
+            const r = ffi.coord_read_peer_role(i);
+            if (r >= 0 and r < 3) by_role[@intCast(r)] += 1;
+        }
+
+        // Per-kind reject window counts + cooldown flags.
+        var reject_counts = [_]c_int{ 0, 0, 0, 0, 0, 0 };
+        var cooldown_flags = [_]c_int{ 0, 0, 0, 0, 0, 0 };
+        var kind_valid = [_]bool{ false, false, false, false, false, false };
+        var ki: c_int = 0;
+        while (ki < 6) : (ki += 1) {
+            const rc = ffi.coord_count_rejects_recent(&token, 16, ki);
+            if (rc < 0) {
+                // First bad-token return short-circuits to 401 — otherwise we'd
+                // silently emit {success:true, ...0s}.
+                if (ki == 0 and rc == -1) return .{ .status = 401, .body = errJson(resp, "unauthenticated") };
+                continue;
+            }
+            reject_counts[@intCast(ki)] = rc;
+            kind_valid[@intCast(ki)] = true;
+            const cd = ffi.coord_kind_in_cooldown(&token, 16, ki);
+            if (cd >= 0) cooldown_flags[@intCast(ki)] = cd;
+        }
+
+        const quar = ffi.coord_count_quarantine(&token, 16);
+        const clm = ffi.coord_count_claims(&token, 16);
+        const trk = ffi.coord_count_track(&token, 16);
+
+        var stream = std.io.fixedBufferStream(resp);
+        const w = stream.writer();
+        std.fmt.format(w,
+            "{{\"success\":true,\"peers\":{{\"active\":{d},\"max\":16," ++
+            "\"by_kind\":{{\"claude\":{d},\"gemini\":{d},\"copilot\":{d},\"custom\":{d},\"openai\":{d},\"mistral\":{d}}}," ++
+            "\"by_role\":{{\"master\":{d},\"journeyman\":{d},\"apprentice\":{d}}}}}," ++
+            "\"quarantine\":{{\"pending\":{d},\"max\":32}}," ++
+            "\"claims\":{{\"active\":{d},\"max\":64}}," ++
+            "\"track\":{{\"entries\":{d},\"max\":512}}," ++
+            "\"rejects\":{{\"window_ms\":600000,\"cooldown_ms\":30000," ++
+            "\"recent_by_kind\":{{\"claude\":{d},\"gemini\":{d},\"copilot\":{d},\"custom\":{d},\"openai\":{d},\"mistral\":{d}}}," ++
+            "\"in_cooldown\":[",
+            .{
+                peer_active,
+                by_kind[0], by_kind[1], by_kind[2], by_kind[3], by_kind[4], by_kind[5],
+                by_role[0], by_role[1], by_role[2],
+                quar, clm, trk,
+                reject_counts[0], reject_counts[1], reject_counts[2], reject_counts[3], reject_counts[4], reject_counts[5],
+            },
+        ) catch return .{ .status = 500, .body = errJson(resp, "buffer overflow") };
+
+        var wrote_cd: bool = false;
+        ki = 0;
+        while (ki < 6) : (ki += 1) {
+            if (cooldown_flags[@intCast(ki)] == 1) {
+                if (wrote_cd) w.writeAll(",") catch return .{ .status = 500, .body = errJson(resp, "buffer overflow") };
+                wrote_cd = true;
+                w.writeAll("\"") catch return .{ .status = 500, .body = errJson(resp, "buffer overflow") };
+                w.writeAll(kindName(ki)) catch return .{ .status = 500, .body = errJson(resp, "buffer overflow") };
+                w.writeAll("\"") catch return .{ .status = 500, .body = errJson(resp, "buffer overflow") };
+            }
+        }
+        w.writeAll("]}}") catch return .{ .status = 500, .body = errJson(resp, "buffer overflow") };
+        return .{ .status = 200, .body = resp[0..stream.pos] };
+    }
+
     return .{ .status = 404, .body = errJson(resp, "not implemented") };
 }
 

cartridges/local-coord-mcp/cartridge.json

@@ -573,7 +573,23 @@
         "type": "object"
       },
       "name": "coord_get_peer_capabilities"
+    },
+    {
+      "description": "Read-only snapshot of coord-mcp state: active peer count (with per-kind / per-role breakdown), pending quarantine depth, active claims, track-record fill, and recent reject counts with cooldown flags. Lets other tooling monitor coord health without walking every export individually.",
+      "inputSchema": {
+        "properties": {
+          "token": {
+            "description": "Session token from coord_register — any active peer may poll.",
+            "type": "string"
+          }
+        },
+        "required": [
+          "token"
+        ],
+        "type": "object"
+      },
+      "name": "coord_health"
     }
   ],
-  "version": "0.7.0"
+  "version": "0.8.0"
 }

cartridges/local-coord-mcp/cartridge.ncl

@@ -11,7 +11,7 @@
   spdx = "PMPL-1.0-or-later",
   copyright = "Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>",
   name = "local-coord-mcp",
-  version = "0.7.0",
+  version = "0.8.0",
   description = "Localhost multi-instance coordination — peer discovery, message passing, and task claiming for parallel AI sessions on the same machine",
   domain = "ai",
   tier = "Ayo",
@@ -295,5 +295,16 @@
         required = ["token", "peer_id"],
       },
     },
+    {
+      name = "coord_health",
+      description = "Read-only snapshot of coord-mcp state: active peer count (with per-kind / per-role breakdown), pending quarantine depth, active claims, track-record fill, and recent reject counts with cooldown flags. Lets other tooling monitor coord health without walking every export individually.",
+      inputSchema = {
+        type = "object",
+        properties = {
+          token = { type = "string", description = "Session token from coord_register — any active peer may poll." },
+        },
+        required = ["token"],
+      },
+    },
   ],
 }

cartridges/local-coord-mcp/ffi/local_coord_ffi.zig

@@ -840,6 +840,89 @@ pub export fn coord_read_peer_provers(peer_idx: c_int, out: [*]u8, out_cap: c_in
     return @intCast(plen);
 }
 
+// ═══════════════════════════════════════════════════════════════════════
+// Health metrics — read-only aggregates over live registries. Exposed so
+// the adapter can render `coord_health` without knowing the registry
+// layout. All functions take the caller's token and return -1 on auth
+// failure so individual peers can poll without a master gate but rogue
+// local processes can't.
+// ═══════════════════════════════════════════════════════════════════════
+
+fn validateToken(token_ptr: [*]const u8, token_len: c_int) bool {
+    return findPeerByToken(token_ptr, @intCast(token_len)) != null;
+}
+
+/// Count active quarantine entries. Returns count, -1 on bad token.
+pub export fn coord_count_quarantine(token_ptr: [*]const u8, token_len: c_int) c_int {
+    mutex.lock();
+    defer mutex.unlock();
+    if (!validateToken(token_ptr, token_len)) return -1;
+    var n: c_int = 0;
+    for (&quarantine) |*q| {
+        if (q.active) n += 1;
+    }
+    return n;
+}
+
+/// Count active claims. Returns count, -1 on bad token.
+pub export fn coord_count_claims(token_ptr: [*]const u8, token_len: c_int) c_int {
+    mutex.lock();
+    defer mutex.unlock();
+    if (!validateToken(token_ptr, token_len)) return -1;
+    var n: c_int = 0;
+    for (&claims) |*c| {
+        if (c.active) n += 1;
+    }
+    return n;
+}
+
+/// Count track-record entries in the ring (saturates at MAX_TRACK).
+/// Returns count, -1 on bad token.
+pub export fn coord_count_track(token_ptr: [*]const u8, token_len: c_int) c_int {
+    mutex.lock();
+    defer mutex.unlock();
+    if (!validateToken(token_ptr, token_len)) return -1;
+    return @intCast(track_count);
+}
+
+/// Count rejections in the current window for the given client_kind.
+/// Returns count, -1 on bad token, -2 on bad kind.
+pub export fn coord_count_rejects_recent(
+    token_ptr: [*]const u8,
+    token_len: c_int,
+    kind: c_int,
+) c_int {
+    mutex.lock();
+    defer mutex.unlock();
+    if (!validateToken(token_ptr, token_len)) return -1;
+    if (kind < 0 or kind >= KIND_COUNT) return -2;
+    const k: usize = @intCast(kind);
+    const now_ms: u64 = @intCast(std.time.milliTimestamp());
+    var n: c_int = 0;
+    for (reject_ring[k]) |ts| {
+        if (ts == 0) continue;
+        if (now_ms > ts and (now_ms - ts) > REJECT_WINDOW_MS) continue;
+        n += 1;
+    }
+    return n;
+}
+
+/// Returns 1 if the given client_kind is currently in reject-cooldown,
+/// 0 otherwise, -1 on bad token, -2 on bad kind.
+pub export fn coord_kind_in_cooldown(
+    token_ptr: [*]const u8,
+    token_len: c_int,
+    kind: c_int,
+) c_int {
+    mutex.lock();
+    defer mutex.unlock();
+    if (!validateToken(token_ptr, token_len)) return -1;
+    if (kind < 0 or kind >= KIND_COUNT) return -2;
+    const ck: ClientKind = @enumFromInt(kind);
+    const now_ms: u64 = @intCast(std.time.milliTimestamp());
+    return if (isInCooldown(ck, now_ms)) 1 else 0;
+}
+
 /// Deregister a peer. Releases any claims it holds.
 pub export fn coord_deregister(token_ptr: [*]const u8, token_len: c_int) c_int {
     mutex.lock();
@@ -2016,7 +2099,7 @@ pub export fn boj_cartridge_name() [*:0]const u8 {
 }
 
 pub export fn boj_cartridge_version() [*:0]const u8 {
-    return "0.7.0";
+    return "0.8.0";
 }
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -2391,6 +2474,40 @@ test "set and read peer capabilities (Task #34)" {
     coord_reset();
 }
 
+test "coord_health counts basics" {
+    coord_reset();
+    var tok1: [TOKEN_LEN]u8 = undefined;
+    var tok2: [TOKEN_LEN]u8 = undefined;
+    var tok3: [TOKEN_LEN]u8 = undefined;
+    var suf: [4]u8 = undefined;
+
+    _ = coord_register(0, -1, &tok1, &suf); // claude → journeyman
+    _ = coord_register(1, -1, &tok2, &suf); // gemini → apprentice
+    _ = coord_register(4, -1, &tok3, &suf); // openai → apprentice
+
+    // Claim from tok1 contributes to active claim count.
+    const t = "health-test-task";
+    try std.testing.expectEqual(@as(c_int, 0), coord_claim_task(&tok1, TOKEN_LEN, t.ptr, @intCast(t.len)));
+
+    // Bad token returns -1.
+    var bad: [TOKEN_LEN]u8 = [_]u8{0} ** TOKEN_LEN;
+    try std.testing.expectEqual(@as(c_int, -1), coord_count_claims(&bad, TOKEN_LEN));
+    try std.testing.expectEqual(@as(c_int, -1), coord_count_quarantine(&bad, TOKEN_LEN));
+    try std.testing.expectEqual(@as(c_int, -1), coord_count_track(&bad, TOKEN_LEN));
+
+    // With a valid token, counts are positive / zero as expected.
+    try std.testing.expectEqual(@as(c_int, 1), coord_count_claims(&tok1, TOKEN_LEN));
+    try std.testing.expectEqual(@as(c_int, 0), coord_count_quarantine(&tok1, TOKEN_LEN));
+    try std.testing.expectEqual(@as(c_int, 0), coord_count_track(&tok1, TOKEN_LEN));
+
+    // Recent-rejects for an unseen kind (mistral=5) is 0; kind out of range is -2.
+    try std.testing.expectEqual(@as(c_int, 0), coord_count_rejects_recent(&tok1, TOKEN_LEN, 5));
+    try std.testing.expectEqual(@as(c_int, -2), coord_count_rejects_recent(&tok1, TOKEN_LEN, 99));
+    try std.testing.expectEqual(@as(c_int, 0), coord_kind_in_cooldown(&tok1, TOKEN_LEN, 0));
+
+    coord_reset();
+}
+
 test "register rejects master role_hint" {
     coord_reset();
     var tok: [TOKEN_LEN]u8 = undefined;