feat(chapel): Enable Chapel accelerator build integration

Wire up the dormant Chapel parallel proof search into the build system:
- Add `chapel` feature flag to Cargo.toml
- Add build.rs to link Zig FFI library when feature enabled
- Update build.zig for Zig 0.14+/0.15+ API compatibility
- Add C header (chapel_ffi_exports.h) defining Chapel ↔ Zig ABI
- Add stub implementations for building/testing without Chapel runtime
- Add Justfile recipes (build-chapel-ffi, test-chapel, chapel-all, etc.)
- Add chapel-ci.yml workflow (Zig FFI build + Rust feature gate CI)
- Fix var→const in chapel_bridge.zig for Zig 0.15 compliance

The Chapel accelerator remains optional (default off). Enable with:
  just build-chapel    # or: cargo build --features chapel

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

Author: hyperpolymath

.github/workflows/chapel-ci.yml

@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+name: Chapel Accelerator CI
+
+on:
+  push:
+    paths:
+      - 'src/zig_ffi/**'
+      - 'src/rust/proof_search.rs'
+      - 'chapel_poc/**'
+      - 'Cargo.toml'
+      - '.github/workflows/chapel-ci.yml'
+  pull_request:
+    paths:
+      - 'src/zig_ffi/**'
+      - 'src/rust/proof_search.rs'
+      - 'chapel_poc/**'
+      - 'Cargo.toml'
+      - '.github/workflows/chapel-ci.yml'
+
+permissions: read-all
+
+jobs:
+  zig-ffi:
+    name: Build & Test Zig FFI Bridge
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+
+      - name: Install Zig
+        uses: goto-bus-stop/setup-zig@7ab2955eb728f5440978d7e4f60155e5e3a9e02f # v2
+        with:
+          version: 0.13.0
+
+      - name: Build Zig FFI library
+        run: cd src/zig_ffi && zig build -Doptimize=ReleaseSafe
+
+      - name: Run Zig FFI tests
+        run: cd src/zig_ffi && zig build test
+
+      - name: Upload FFI library artifact
+        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+        with:
+          name: chapel-ffi-lib
+          path: src/zig_ffi/zig-out/lib/
+
+  rust-chapel-feature:
+    name: Rust Build with Chapel Feature
+    runs-on: ubuntu-latest
+    needs: zig-ffi
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@4be9e76fd7c4901c61fb841f559994984270fce7 # stable
+        with:
+          toolchain: stable
+
+      - name: Rust cache
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+
+      - name: Download FFI library
+        uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4
+        with:
+          name: chapel-ffi-lib
+          path: src/zig_ffi/zig-out/lib/
+
+      - name: Build with chapel feature
+        run: cargo build --features chapel
+
+      - name: Test with chapel feature
+        run: cargo test --features chapel -- proof_search

Cargo.toml

@@ -69,6 +69,10 @@ lazy_static = "1"
 # Chrono for timestamps
 chrono = { version = "0.4", features = ["serde"] }
 
+[features]
+default = []
+chapel = []  # Enable Chapel parallel proof search (requires Zig FFI library)
+
 [dev-dependencies]
 proptest = "1"
 tempfile = "3"

Justfile

@@ -96,6 +96,42 @@ container-build-full:
 container-run *ARGS:
     podman run --rm -it echidna:latest {{ARGS}}
 
+# ── Chapel Accelerator ──────────────────────────────────────
+
+# Build Zig FFI bridge for Chapel (prerequisite for --features chapel)
+build-chapel-ffi:
+    @echo "Building Zig FFI bridge..."
+    cd src/zig_ffi && zig build -Doptimize=ReleaseSafe
+    @echo "Library built at src/zig_ffi/zig-out/lib/"
+
+# Build Chapel PoC (requires Chapel compiler)
+build-chapel-poc:
+    @echo "Building Chapel proof-of-concept..."
+    cd chapel_poc && chpl parallel_proof_search.chpl -o proof_search --fast
+    @echo "Built chapel_poc/proof_search"
+
+# Run Chapel PoC benchmark
+run-chapel-poc:
+    cd chapel_poc && ./proof_search
+
+# Build with Chapel support enabled (requires Zig FFI built first)
+build-chapel: build-chapel-ffi
+    cargo build --features chapel
+
+# Test Chapel integration
+test-chapel: build-chapel-ffi
+    cargo test --features chapel -- proof_search
+
+# Test Zig FFI bridge independently
+test-chapel-ffi:
+    cd src/zig_ffi && zig build test
+
+# Full Chapel build + test
+chapel-all: build-chapel-poc build-chapel-ffi test-chapel
+    @echo "Chapel accelerator fully built and tested"
+
+# ── Other ───────────────────────────────────────────────────
+
 # [AUTO-GENERATED] Multi-arch / RISC-V target
 build-riscv:
 	@echo "Building for RISC-V..."

build.rs

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+//! Build script for ECHIDNA
+//!
+//! When the `chapel` feature is enabled, this links against the Zig-built
+//! Chapel FFI bridge library (libechidna_chapel_ffi).
+//!
+//! Build order: Chapel (.chpl) → C headers → Zig (chapel_bridge.zig) → Rust (proof_search.rs)
+
+fn main() {
+    // Only link Chapel FFI when the feature is enabled
+    #[cfg(feature = "chapel")]
+    {
+        // Look for the Zig-built library in src/zig_ffi/zig-out/lib/
+        let zig_ffi_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("src")
+            .join("zig_ffi")
+            .join("zig-out")
+            .join("lib");
+
+        if zig_ffi_dir.exists() {
+            println!("cargo:rustc-link-search=native={}", zig_ffi_dir.display());
+            println!("cargo:rustc-link-lib=static=echidna_chapel_ffi");
+            println!("cargo:rustc-link-lib=dylib=c");
+        } else {
+            // Also check standard install location
+            let alt_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                .join("lib");
+            if alt_dir.exists() {
+                println!("cargo:rustc-link-search=native={}", alt_dir.display());
+                println!("cargo:rustc-link-lib=static=echidna_chapel_ffi");
+                println!("cargo:rustc-link-lib=dylib=c");
+            } else {
+                println!("cargo:warning=Chapel FFI library not found. Build it first with: just build-chapel-ffi");
+                println!("cargo:warning=Looked in: {}", zig_ffi_dir.display());
+            }
+        }
+
+        // Re-run if FFI source changes
+        println!("cargo:rerun-if-changed=src/zig_ffi/chapel_bridge.zig");
+        println!("cargo:rerun-if-changed=src/zig_ffi/build.zig");
+    }
+}

src/zig_ffi/build.zig

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: PMPL-1.0-or-later
 // ECHIDNA Zig FFI Build Configuration
+// Compatible with Zig 0.14+/0.15+
 
 const std = @import("std");
 
@@ -8,58 +9,51 @@ pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     // Build shared library for FFI
-    const lib = b.addSharedLibrary(.{
+    const lib = b.addLibrary(.{
         .name = "echidna_chapel_ffi",
-        .root_source_file = b.path("chapel_bridge.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("chapel_bridge.zig"),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+        }),
+        .linkage = .dynamic,
     });
-
-    // Link with C (required for Chapel interop)
-    lib.linkLibC();
-
-    // Set version
-    lib.version = .{ .major = 1, .minor = 0, .patch = 0 };
+    // Chapel C headers are in the same directory
+    lib.root_module.addIncludePath(b.path("."));
 
     // Install artifacts
     b.installArtifact(lib);
 
     // Static library (alternative)
-    const lib_static = b.addStaticLibrary(.{
+    const lib_static = b.addLibrary(.{
         .name = "echidna_chapel_ffi",
-        .root_source_file = b.path("chapel_bridge.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("chapel_bridge.zig"),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+        }),
+        .linkage = .static,
     });
+    lib_static.root_module.addIncludePath(b.path("."));
 
-    lib_static.linkLibC();
     b.installArtifact(lib_static);
 
-    // Unit tests
+    // Unit tests (link against stubs when Chapel not available)
     const lib_tests = b.addTest(.{
-        .root_source_file = b.path("chapel_bridge.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("chapel_bridge.zig"),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+        }),
     });
-
-    lib_tests.linkLibC();
+    lib_tests.root_module.addIncludePath(b.path("."));
+    lib_tests.addCSourceFile(.{ .file = b.path("chapel_stubs.c") });
 
     const run_lib_tests = b.addRunArtifact(lib_tests);
 
     const test_step = b.step("test", "Run FFI tests");
     test_step.dependOn(&run_lib_tests.step);
-
-    // Documentation
-    const docs = b.addTest(.{
-        .root_source_file = b.path("chapel_bridge.zig"),
-        .target = target,
-        .optimize = .Debug,
-    });
-
-    const docs_step = b.step("docs", "Generate documentation");
-    docs_step.dependOn(&b.addInstallDirectory(.{
-        .source_dir = docs.getEmittedDocs(),
-        .install_dir = .prefix,
-        .install_subdir = "docs",
-    }).step);
 }

src/zig_ffi/chapel_bridge.zig

@@ -214,7 +214,7 @@ pub fn parallelProofSearch(
     );
 
     // Convert Chapel result to Zig (takes ownership of strings)
-    var result = try ProofResult.fromChapel(c_result, allocator);
+    const result = try ProofResult.fromChapel(c_result, allocator);
 
     // Free Chapel-allocated strings (we've copied them)
     chapel.chapel_free_result(@constCast(&c_result));

src/zig_ffi/chapel_ffi_exports.h

@@ -0,0 +1,57 @@
+/* SPDX-License-Identifier: PMPL-1.0-or-later */
+/* ECHIDNA Chapel FFI Exports — C header interface
+ *
+ * This header defines the C ABI that Chapel's `export` functions provide.
+ * When Chapel is compiled, it generates compatible symbols.
+ * When Chapel is NOT available, stub implementations return "unavailable".
+ *
+ * The Zig bridge (@cImport) imports this header and wraps it type-safely.
+ */
+
+#ifndef ECHIDNA_CHAPEL_FFI_EXPORTS_H
+#define ECHIDNA_CHAPEL_FFI_EXPORTS_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* C-compatible proof result from Chapel's parallel search */
+typedef struct {
+    int success;           /* 0 = false, 1 = true */
+    int prover_id;         /* ProverKind enum value (-1 if unknown) */
+    double time_seconds;
+    uint32_t tactic_count;
+    const char *prover_name;    /* NULL or heap-allocated string */
+    const char *error_message;  /* NULL or heap-allocated string */
+} CProofResult;
+
+/* Main entry point: parallel proof search across all Chapel-managed provers.
+ * goal:        null-terminated theorem statement
+ * prover_ids:  array of prover IDs to use (NULL = all provers)
+ * num_provers: length of prover_ids (0 = all provers)
+ * Returns:     CProofResult (caller must free via chapel_free_result) */
+CProofResult chapel_parallel_search(
+    const char *goal,
+    const int *prover_ids,
+    int num_provers
+);
+
+/* Free a CProofResult returned by chapel_parallel_search */
+void chapel_free_result(CProofResult *result);
+
+/* Check if Chapel runtime is available (returns 1 if yes, 0 if no) */
+int chapel_is_available(void);
+
+/* Get Chapel metalayer version string (caller must free via chapel_free_string) */
+const char *chapel_get_version(void);
+
+/* Free a string returned by chapel_get_version */
+void chapel_free_string(const char *str);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ECHIDNA_CHAPEL_FFI_EXPORTS_H */

src/zig_ffi/chapel_stubs.c

@@ -0,0 +1,46 @@
+/* SPDX-License-Identifier: PMPL-1.0-or-later */
+/* Stub implementations of Chapel FFI exports for testing/building
+ * without the Chapel runtime. These return "unavailable" gracefully. */
+
+#include "chapel_ffi_exports.h"
+#include <stdlib.h>
+#include <string.h>
+
+CProofResult chapel_parallel_search(
+    const char *goal,
+    const int *prover_ids,
+    int num_provers
+) {
+    (void)goal;
+    (void)prover_ids;
+    (void)num_provers;
+    CProofResult result = {0};
+    result.success = 0;
+    result.prover_id = -1;
+    result.time_seconds = 0.0;
+    result.tactic_count = 0;
+    result.prover_name = NULL;
+    result.error_message = strdup("Chapel runtime not available (stub)");
+    return result;
+}
+
+void chapel_free_result(CProofResult *result) {
+    if (result) {
+        free((void *)result->prover_name);
+        free((void *)result->error_message);
+        result->prover_name = NULL;
+        result->error_message = NULL;
+    }
+}
+
+int chapel_is_available(void) {
+    return 0; /* Not available in stub mode */
+}
+
+const char *chapel_get_version(void) {
+    return NULL; /* No version in stub mode */
+}
+
+void chapel_free_string(const char *str) {
+    free((void *)str);
+}