feat: migrate to Idris2 ABI + Zig FFI universal standard

- Fix Cargo.toml license (PMPL-1.0-or-later) and add author
- Create Idris2 ABI layer at src/abi/ with dependent type proofs
  - Types.idr: Non-null handles, Result/ValueType enums
  - Layout.idr: Memory layout verification
  - Foreign.idr: FFI function declarations
- Create Zig FFI implementation at ffi/zig/
  - build.zig: Build system for shared library and tests
  - src/main.zig: C-compatible FFI layer
  - test/integration_test.zig: Integration tests
- Update Rust FFI functions with rust_ prefix (src/ffi/c_api.rs)
- Add ABI-FFI-README.md comprehensive documentation
- Update STATE.scm with session accomplishments

Follows hyperpolymath ABI/FFI Universal Standard.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: Test

.machine_readable/STATE.scm

@@ -1,4 +1,4 @@
-;; SPDX-License-Identifier: AGPL-3.0-or-later
+;; SPDX-License-Identifier: PMPL-1.0-or-later
 ;; STATE.scm - Project state for wokelang
 ;; Media-Type: application/vnd.state+scm
 
@@ -7,7 +7,7 @@
     (version "0.1.0")
     (schema-version "1.0")
     (created "2026-01-03")
-    (updated "2026-01-04")
+    (updated "2026-01-31")
     (project "wokelang")
     (repo "github.com/hyperpolymath/wokelang"))
 
@@ -51,12 +51,23 @@
 
   (blockers-and-issues
     (high "Type system design not finalized")
-    (medium "Worker implementation incomplete"))
+    (medium "Worker implementation incomplete")
+    (resolved "License updated to PMPL-1.0-or-later" "2026-01-31")
+    (resolved "ABI/FFI architecture migrated to Idris2+Zig standard" "2026-01-31"))
 
   (critical-next-actions
     (immediate "Complete bytecode VM" "Add unit tests")
     (this-week "Implement type inference")
     (this-month "Complete Phase 2"))
 
   (session-history
-    (session "2026-01-04" "Updated SCM files")))
+    (session "2026-01-04" "Updated SCM files")
+    (session "2026-01-31"
+      (accomplishments
+        "Fixed Cargo.toml license (PMPL-1.0-or-later)"
+        "Added author field to Cargo.toml"
+        "Created Idris2 ABI layer (src/abi/)"
+        "Created Zig FFI implementation (ffi/zig/)"
+        "Updated Rust FFI with rust_ prefix"
+        "Created ABI-FFI-README.md documentation"
+        "Migrated to universal ABI/FFI standard"))))

ABI-FFI-README.md

@@ -0,0 +1,265 @@
+# WokeLang ABI/FFI Architecture
+
+This document describes the WokeLang ABI (Application Binary Interface) and FFI (Foreign Function Interface) architecture.
+
+## Architecture Overview
+
+WokeLang follows the **Idris2 ABI + Zig FFI** universal standard:
+
+```
+┌─────────────────────────────────────────────┐
+│ Idris2 ABI Layer (src/abi/)                 │
+│ - Type definitions with proofs              │
+│ - Memory layout verification                │
+│ - Platform-specific ABI guarantees          │
+└─────────────────────────────────────────────┘
+                    ↓
+┌─────────────────────────────────────────────┐
+│ Zig FFI Layer (ffi/zig/)                    │
+│ - C-compatible implementation               │
+│ - Zero-cost abstractions                    │
+│ - Cross-platform compilation                │
+└─────────────────────────────────────────────┘
+                    ↓
+┌─────────────────────────────────────────────┐
+│ Rust Core (src/ffi/c_api.rs)                │
+│ - Core interpreter implementation           │
+│ - Memory management                         │
+│ - Language semantics                        │
+└─────────────────────────────────────────────┘
+```
+
+## Directory Structure
+
+```
+wokelang/
+├── src/
+│   └── abi/                    # Idris2 ABI definitions
+│       ├── Types.idr           # Type definitions with dependent type proofs
+│       ├── Layout.idr          # Memory layout verification
+│       └── Foreign.idr         # FFI declarations
+│
+├── ffi/
+│   └── zig/                    # Zig FFI implementation
+│       ├── build.zig           # Build configuration
+│       ├── src/
+│       │   └── main.zig        # C-compatible FFI functions
+│       └── test/
+│           └── integration_test.zig
+│
+├── generated/
+│   └── abi/                    # Auto-generated C headers
+│       └── wokelang.h          # (Generated from Idris2)
+│
+└── bindings/                   # Language-specific wrappers (future)
+    ├── rescript/
+    └── julia/
+```
+
+## Layer Responsibilities
+
+### 1. Idris2 ABI Layer (`src/abi/`)
+
+**Purpose**: Formal specification with compile-time proofs
+
+**Guarantees**:
+- Non-null pointer types (using dependent types)
+- Correct memory layout across platforms
+- ABI compatibility between versions
+- Type-safe foreign function declarations
+
+**Files**:
+- `Types.idr`: Core type definitions (`InterpreterHandle`, `ValueHandle`, `Result`, `ValueType`)
+- `Layout.idr`: Platform-specific layout proofs
+- `Foreign.idr`: FFI function declarations
+
+**Example Proof**:
+```idris
+-- Non-null pointer guaranteed at type level
+data InterpreterHandle : Type where
+  MkInterpreterHandle : (ptr : Bits64) -> {auto 0 nonNull : So (ptr /= 0)} -> InterpreterHandle
+```
+
+### 2. Zig FFI Layer (`ffi/zig/`)
+
+**Purpose**: C-compatible implementation with safety
+
+**Features**:
+- Native C ABI compatibility
+- Memory-safe by default
+- Cross-compilation support
+- Zero runtime overhead
+
+**Functions**:
+- Interpreter lifecycle: `woke_interpreter_new`, `woke_interpreter_free`
+- Execution: `woke_exec`, `woke_eval`
+- Value operations: `woke_value_*` functions
+- Utility: `woke_version`, `woke_last_error`
+
+**Example**:
+```zig
+export fn woke_interpreter_new() ?*InterpreterHandle {
+    return rust_woke_interpreter_new();
+}
+```
+
+### 3. Rust Core (`src/ffi/c_api.rs`)
+
+**Purpose**: Core language implementation
+
+**Responsibilities**:
+- Lexer, parser, interpreter
+- Memory management (Box allocation)
+- Error handling
+- Value representation
+
+## Building
+
+### Build Rust Core
+```bash
+cargo build --release
+```
+
+### Build Zig FFI
+```bash
+cd ffi/zig
+zig build
+zig build test      # Run integration tests
+zig build example   # Run example
+```
+
+### Verify ABI Compliance
+```bash
+# Compile Idris2 ABI (generates C headers)
+cd src/abi
+idris2 --build wokelang-abi.ipkg
+```
+
+## API Reference
+
+### Interpreter Lifecycle
+
+```c
+// Create interpreter (returns NULL on failure)
+InterpreterHandle* woke_interpreter_new(void);
+
+// Free interpreter
+void woke_interpreter_free(InterpreterHandle* interp);
+```
+
+### Execution
+
+```c
+// Execute code (returns Result code)
+Result woke_exec(InterpreterHandle* interp, const char* source);
+
+// Evaluate expression and get value
+Result woke_eval(InterpreterHandle* interp, const char* source, ValueHandle** out_value);
+```
+
+### Value Operations
+
+```c
+// Free value
+void woke_value_free(ValueHandle* value);
+
+// Get value type
+ValueType woke_value_type(const ValueHandle* value);
+
+// Extract values
+Result woke_value_as_int(const ValueHandle* value, long long* out);
+Result woke_value_as_float(const ValueHandle* value, double* out);
+Result woke_value_as_bool(const ValueHandle* value, int* out);
+char* woke_value_as_string(const ValueHandle* value);  // Must free with woke_string_free
+
+// Create values
+ValueHandle* woke_value_from_int(long long n);
+ValueHandle* woke_value_from_float(double f);
+ValueHandle* woke_value_from_bool(int b);
+ValueHandle* woke_value_from_string(const char* s);
+```
+
+### Utility
+
+```c
+// Get version string
+const char* woke_version(void);
+
+// Get last error message (NULL if no error)
+const char* woke_last_error(void);
+```
+
+## Example Usage
+
+### Zig
+```zig
+const woke = @import("wokelang");
+
+pub fn main() !void {
+    var interp = woke.woke_interpreter_new() orelse return error.InitFailed;
+    defer woke.woke_interpreter_free(interp);
+
+    const result = woke.woke_exec(interp,
+        \\to greet(name: String) -> String {
+        \\    give back "Hello, " + name + "!";
+        \\}
+        \\to main() {
+        \\    hello greet("World");
+        \\}
+    );
+
+    if (result != .ok) return error.ExecutionFailed;
+}
+```
+
+### C
+```c
+#include "wokelang.h"
+
+int main(void) {
+    InterpreterHandle* interp = woke_interpreter_new();
+    if (!interp) return 1;
+
+    Result result = woke_exec(interp, "remember x = 42;");
+
+    woke_interpreter_free(interp);
+    return (result == Ok) ? 0 : 1;
+}
+```
+
+## Safety Guarantees
+
+### Compile-Time (Idris2)
+- Non-null pointers
+- Correct struct alignment
+- Platform ABI compatibility
+- Type-safe foreign calls
+
+### Runtime (Zig)
+- Null pointer checks
+- Memory safety
+- No undefined behavior
+
+### Implementation (Rust)
+- Memory safety via ownership
+- No data races
+- Safe FFI boundary
+
+## Migration from Old FFI
+
+The old FFI (`zig/wokelang.zig`) is deprecated. Use the new structure:
+
+**Old**: `zig/wokelang.zig` (wrapper around Rust)
+**New**: `ffi/zig/src/main.zig` (proper FFI layer with ABI definitions)
+
+The new structure provides:
+- Formal ABI guarantees (Idris2 proofs)
+- Better separation of concerns
+- Cross-platform compatibility
+- Standard directory layout
+
+## References
+
+- [ABI/FFI Universal Standard](../../ffi-migration-guide.md)
+- [Idris2 FFI Documentation](https://idris2.readthedocs.io/en/latest/ffi/ffi.html)
+- [Zig FFI Guide](https://ziglang.org/documentation/master/#C)

Cargo.toml

@@ -2,8 +2,9 @@
 name = "wokelang"
 version = "0.1.0"
 edition = "2021"
+authors = ["Jonathan D.A. Jewell <jonathan.jewell@open.ac.uk>"]
 description = "A human-centered, consent-driven programming language"
-license = "MIT OR AGPL-3.0-or-later"
+license = "PMPL-1.0-or-later"
 repository = "https://github.com/hyperpolymath/wokelang"
 
 [lib]

ffi/zig/build.zig

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// SPDX-FileCopyrightText: 2025 Jonathan D.A. Jewell
+
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    // Build shared library
+    const lib = b.addSharedLibrary(.{
+        .name = "wokelang",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Link with Rust implementation
+    lib.linkLibC();
+    lib.addLibraryPath(b.path("../../target/release"));
+    lib.linkSystemLibrary("wokelang");
+
+    b.installArtifact(lib);
+
+    // Build tests
+    const tests = b.addTest(.{
+        .root_source_file = b.path("test/integration_test.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    tests.linkLibrary(lib);
+
+    const run_tests = b.addRunArtifact(tests);
+    const test_step = b.step("test", "Run integration tests");
+    test_step.dependOn(&run_tests.step);
+
+    // Build example
+    const example = b.addExecutable(.{
+        .name = "example",
+        .root_source_file = b.path("../../zig/example.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    example.linkLibrary(lib);
+
+    const run_example = b.addRunArtifact(example);
+    const example_step = b.step("example", "Run example");
+    example_step.dependOn(&run_example.step);
+}