chore: automated sync of local changes

Author: hyperpolymath

cartridges/007-mcp/adapter/oo7_adapter.zig

@@ -199,6 +199,9 @@ fn dispatchTool(
     };
     defer inv.deinit(allocator);
 
+    const cleaned_stderr = try stripKnownNoise(allocator, inv.stderr);
+    defer if (cleaned_stderr.ptr != inv.stderr.ptr) allocator.free(cleaned_stderr);
+
     var w = out.writer(allocator);
     try w.writeAll("{\"success\":");
     try w.writeAll(if (inv.exit_code == 0) "true" else "false");
@@ -207,11 +210,47 @@ fn dispatchTool(
     try w.writeAll(",\"stdout\":");
     try writeJsonString(w, inv.stdout);
     try w.writeAll(",\"stderr\":");
-    try writeJsonString(w, inv.stderr);
+    try writeJsonString(w, cleaned_stderr);
     try w.writeByte('}');
     return 200;
 }
 
+fn isKnownNoiseLine(line: []const u8) bool {
+    if (std.mem.eql(u8, line, "warning: profiles for the non root package will be ignored, specify profiles at the workspace root:")) {
+        return true;
+    }
+    if (std.mem.startsWith(u8, line, "package:") and std.mem.indexOf(u8, line, "/linker/Cargo.toml") != null) {
+        return true;
+    }
+    if (std.mem.startsWith(u8, line, "workspace:") and std.mem.indexOf(u8, line, "/Cargo.toml") != null) {
+        return true;
+    }
+    return false;
+}
+
+/// Strip repetitive low-signal Cargo workspace-profile warnings from stderr.
+/// Returns the original slice when no filtering was applied.
+fn stripKnownNoise(allocator: std.mem.Allocator, stderr: []const u8) ![]const u8 {
+    if (stderr.len == 0) return stderr;
+
+    var out = std.ArrayList(u8).initCapacity(allocator, stderr.len) catch return stderr;
+    defer out.deinit(allocator);
+
+    var changed = false;
+    var line_it = std.mem.splitScalar(u8, stderr, '\n');
+    while (line_it.next()) |line| {
+        if (isKnownNoiseLine(line)) {
+            changed = true;
+            continue;
+        }
+        try out.appendSlice(allocator, line);
+        try out.append(allocator, '\n');
+    }
+
+    if (!changed) return stderr;
+    return try out.toOwnedSlice(allocator);
+}
+
 // ═══════════════════════════════════════════════════════════════════════
 // Main — HTTP server
 // ═══════════════════════════════════════════════════════════════════════

cartridges/007-mcp/ffi/oo7_mcp_ffi.zig

@@ -32,6 +32,7 @@ pub const BIND_PORT: u16 = 1066;
 
 /// Coord server URL — cartridge acts as a client during OnEnter/OnExit.
 pub const COORD_URL = "http://127.0.0.1:7745";
+pub const COORD_REGISTER_URL = COORD_URL ++ "/tools/coord_register";
 
 pub const MAX_TOOL_NAME: usize = 48;
 pub const MAX_ARG_STRING: usize = 4096;
@@ -264,14 +265,17 @@ pub const EnterResult = struct {
     methodology_files: []const []const u8,
     memory_hits: []const []const u8,
     pub fn deinit(self: *EnterResult, allocator: std.mem.Allocator) void {
+        for (self.methodology_files) |p| allocator.free(p);
         allocator.free(self.methodology_files);
+        for (self.memory_hits) |p| allocator.free(p);
         allocator.free(self.memory_hits);
     }
 };
 
 /// OnEnter: register as coord peer (soft-fail to Degraded), load 6a2,
 /// run memory auto-lift. Idempotent: re-calling from Registered or
-/// Degraded is a no-op that returns the cached peer_id.
+/// Degraded is a no-op that returns the cached peer_id. Re-entering
+/// after Deregistered starts a new registration attempt.
 ///
 /// The adapter handles the HTTP framing; this function only does the
 /// state transition + the coord POST + the file-system reads.
@@ -283,18 +287,40 @@ pub fn onEnter(
     _ = session_hint; // surfaced in future; no state effect today
 
     const cur = state();
-    if (cur == .registered or cur == .degraded) {
+    if (cur == .registered) {
         // Idempotent — return the existing identity and a re-read methodology pack.
         const methodology = try readMethodologyPack(allocator, worktree);
         const memory = try memoryAutolift(allocator, worktree);
         return .{
             .peer_id = peerId(),
-            .coord_state = if (cur == .registered) "registered" else "degraded",
+            .coord_state = "registered",
             .methodology_files = methodology,
             .memory_hits = memory,
         };
     }
-    if (cur != .fresh) return error.BadState;
+    if (cur == .degraded) {
+        // Retry registration so degraded sessions can self-heal when
+        // local-coord-mcp becomes reachable again.
+        const upgraded = coordRegister(allocator) catch false;
+        if (upgraded) {
+            setState(.registered);
+        } else if (g_peer_id_len == 0) {
+            const local_id = "claude-0000@007-lang-local";
+            @memcpy(g_peer_id_buf[0..local_id.len], local_id);
+            g_peer_id_len = local_id.len;
+            g_coord_token_len = 0;
+        }
+
+        const methodology = try readMethodologyPack(allocator, worktree);
+        const memory = try memoryAutolift(allocator, worktree);
+        return .{
+            .peer_id = peerId(),
+            .coord_state = if (state() == .registered) "registered" else "degraded",
+            .methodology_files = methodology,
+            .memory_hits = memory,
+        };
+    }
+    if (cur != .fresh and cur != .deregistered) return error.BadState;
 
     // Try coord_register. Soft-fail to Degraded on any error.
     const registered = coordRegister(allocator) catch |e| blk: {
@@ -310,6 +336,7 @@ pub fn onEnter(
         const local_id = "claude-0000@007-lang-local";
         @memcpy(g_peer_id_buf[0..local_id.len], local_id);
         g_peer_id_len = local_id.len;
+        g_coord_token_len = 0;
     }
 
     const methodology = try readMethodologyPack(allocator, worktree);
@@ -327,6 +354,7 @@ pub const ExitResult = struct {
     drift_findings: []const []const u8,
     coord_state: []const u8,
     pub fn deinit(self: *ExitResult, allocator: std.mem.Allocator) void {
+        for (self.drift_findings) |p| allocator.free(p);
         allocator.free(self.drift_findings);
     }
 };
@@ -343,12 +371,12 @@ pub fn onExit(
 
     const findings = try driftCheck(allocator, worktree);
 
-    if (cur == .registered) {
-        // Best-effort coord deregister; failure is logged but not fatal.
-        coordDeregister(allocator) catch |e| {
+    // Best-effort coord teardown; failure is non-fatal.
+    coordDeregister(allocator) catch |e| {
+        if (cur == .registered) {
             std.log.warn("007-mcp: coord_deregister failed ({}); proceeding to Deregistered", .{e});
-        };
-    }
+        }
+    };
 
     setState(.deregistered);
     return .{
@@ -384,11 +412,19 @@ fn readMethodologyPack(
         // explicit sentinel like "MISSING::<path>".
         var path_buf: [std.fs.max_path_bytes]u8 = undefined;
         const full = std.fmt.bufPrint(&path_buf, "{s}/{s}", .{ worktree, rel }) catch rel;
-        std.fs.accessAbsolute(full, .{}) catch {
-            const missing = try std.fmt.allocPrint(allocator, "MISSING::{s}", .{rel});
-            out[i] = missing;
-            continue;
-        };
+        if (std.fs.path.isAbsolute(full)) {
+            std.fs.accessAbsolute(full, .{}) catch {
+                const missing = try std.fmt.allocPrint(allocator, "MISSING::{s}", .{rel});
+                out[i] = missing;
+                continue;
+            };
+        } else {
+            std.fs.cwd().access(full, .{}) catch {
+                const missing = try std.fmt.allocPrint(allocator, "MISSING::{s}", .{rel});
+                out[i] = missing;
+                continue;
+            };
+        }
         out[i] = try allocator.dupe(u8, rel);
     }
     return out;
@@ -427,6 +463,13 @@ pub const TAG_MAP_PATHS = [_][]const u8{
     "/var/mnt/eclipse/repos/boj-server/cartridges/007-mcp/schemas/memory-tag-map.a2ml",
 };
 
+fn openMaybeAbsolute(path: []const u8) !std.fs.File {
+    if (std.fs.path.isAbsolute(path)) {
+        return try std.fs.openFileAbsolute(path, .{});
+    }
+    return try std.fs.cwd().openFile(path, .{});
+}
+
 /// Read the tag map from disk (first candidate that exists wins).
 /// Caller owns the returned slice.
 fn readTagMap(allocator: std.mem.Allocator, worktree: []const u8) ![]u8 {
@@ -436,7 +479,7 @@ fn readTagMap(allocator: std.mem.Allocator, worktree: []const u8) ![]u8 {
             rel
         else
             std.fmt.bufPrint(&path_buf, "{s}/{s}", .{ worktree, rel }) catch continue;
-        const file = std.fs.openFileAbsolute(full, .{}) catch continue;
+        const file = openMaybeAbsolute(full) catch continue;
         defer file.close();
         const stat = try file.stat();
         const buf = try allocator.alloc(u8, stat.size);
@@ -570,24 +613,57 @@ fn driftCheck(
 
 // ─── Coord client ──────────────────────────────────────────────────────
 
-/// POST coord_register to local-coord-mcp. Returns true on success.
-/// Current implementation returns false (Degraded) when the socket isn't
-/// reachable — the adapter layer owns the actual HTTP write and token
-/// parse. Kept as a hookable function here so tests can stub it.
+/// POST coord_register to local-coord-mcp.
+/// Returns true only when an HTTP 200 response carries
+/// {"success":true,"peer_id":"...","token":"..."}.
 fn coordRegister(allocator: std.mem.Allocator) !bool {
-    _ = allocator;
-    // Probe TCP connect to 127.0.0.1:7745; any failure → Degraded.
-    const addr = std.net.Address.initIp4(BIND_ADDR, 7745);
-    const sock = std.net.tcpConnectToAddress(addr) catch return false;
-    sock.close();
-    // Real register happens in the adapter layer where the HTTP client
-    // is wired; here we only certify reachability.
-    const synth = "claude-007a@007-lang";
-    @memcpy(g_peer_id_buf[0..synth.len], synth);
-    g_peer_id_len = synth.len;
-    const tok = "0000000000000000000000000000000000000000000000000000000000000000";
-    @memcpy(g_coord_token_buf[0..64], tok);
-    g_coord_token_len = 64;
+    g_peer_id_len = 0;
+    g_coord_token_len = 0;
+
+    var client = std.http.Client{ .allocator = allocator };
+    defer client.deinit();
+
+    const uri = std.Uri.parse(COORD_REGISTER_URL) catch return false;
+    const payload = "{\"client_kind\":\"claude\",\"context\":\"007-lang\"}";
+
+    var headers_buf: [2]std.http.Header = .{
+        .{ .name = "Content-Type", .value = "application/json" },
+        .{ .name = "User-Agent", .value = "007-mcp/0.1 coord-register" },
+    };
+
+    var aw: std.Io.Writer.Allocating = .init(allocator);
+    defer aw.deinit();
+
+    const fetch_result = client.fetch(.{
+        .method = .POST,
+        .location = .{ .uri = uri },
+        .extra_headers = &headers_buf,
+        .payload = payload,
+        .response_writer = &aw.writer,
+    }) catch return false;
+
+    if (@intFromEnum(fetch_result.status) != 200) return false;
+
+    const body = aw.writer.buffered();
+    const parsed = std.json.parseFromSlice(std.json.Value, allocator, body, .{}) catch return false;
+    defer parsed.deinit();
+
+    const obj = if (parsed.value == .object) parsed.value.object else return false;
+    const ok_val = obj.get("success") orelse return false;
+    if (ok_val != .bool or !ok_val.bool) return false;
+    const peer_id_val = obj.get("peer_id") orelse return false;
+    const token_val = obj.get("token") orelse return false;
+    if (peer_id_val != .string or token_val != .string) return false;
+
+    const peer_id = peer_id_val.string;
+    const token = token_val.string;
+    if (peer_id.len == 0 or peer_id.len > g_peer_id_buf.len) return false;
+    if (token.len == 0 or token.len > g_coord_token_buf.len) return false;
+
+    @memcpy(g_peer_id_buf[0..peer_id.len], peer_id);
+    g_peer_id_len = peer_id.len;
+    @memcpy(g_coord_token_buf[0..token.len], token);
+    g_coord_token_len = token.len;
     return true;
 }
 
@@ -624,6 +700,15 @@ test "lifecycle state round-trip" {
     setState(.fresh); // reset for other tests
 }
 
+test "onEnter accepts re-entry from deregistered state" {
+    setState(.deregistered);
+    var enter = try onEnter(std.testing.allocator, ".", "");
+    defer enter.deinit(std.testing.allocator);
+
+    try std.testing.expect(enter.peer_id.len > 0);
+    try std.testing.expect(std.mem.eql(u8, enter.coord_state, "registered") or std.mem.eql(u8, enter.coord_state, "degraded"));
+}
+
 test "matchMemories picks memories from matching tag blocks only" {
     const map =
         \\;; comment line

proofs/canonical-proof-suite/M1.sidecar.a2ml

@@ -11,6 +11,6 @@
   (expected-symbol "infinitudeOfPrimes")
   (semantic-check "verified")
   (status "passing")
-  (elapsed-ms 3422)
+  (elapsed-ms 3346)
   (banned-constructs-found "")
-  (last-checked-utc "2026-04-19T02:48:09Z"))
+  (last-checked-utc "2026-04-19T18:32:17Z"))

proofs/canonical-proof-suite/M2.sidecar.a2ml

@@ -11,6 +11,6 @@
   (expected-symbol "lagrangeTheorem")
   (semantic-check "verified")
   (status "passing")
-  (elapsed-ms 1846)
+  (elapsed-ms 1482)
   (banned-constructs-found "")
-  (last-checked-utc "2026-04-19T02:48:11Z"))
+  (last-checked-utc "2026-04-19T18:32:18Z"))

proofs/canonical-proof-suite/M3.sidecar.a2ml

@@ -11,6 +11,6 @@
   (expected-symbol "intermediate_value_theorem")
   (semantic-check "verified")
   (status "passing")
-  (elapsed-ms 1479)
+  (elapsed-ms 1056)
   (banned-constructs-found "")
-  (last-checked-utc "2026-04-19T02:48:12Z"))
+  (last-checked-utc "2026-04-19T18:32:19Z"))