Merge pull request #9 from rand/feat/go-hooks

feat: Go hook binaries, event coordination, and rlm-core default enablement

Author: rand

.claude-plugin/marketplace.json

@@ -1,6 +1,6 @@
 {
   "name": "rlm-claude-code",
-  "description": "Marketplace for RLM-Claude-Code: Recursive Language Model with intelligent multi-provider routing",
+  "description": "Marketplace for RLM-Claude-Code: Recursive Language Model with Go hook binaries, cross-plugin event system, and intelligent multi-provider routing",
   "owner": {
     "name": "rand",
     "url": "https://github.com/rand"
@@ -9,8 +9,8 @@
     {
       "name": "rlm-claude-code",
       "source": "./",
-      "description": "Recursive Language Model integration for Claude Code - intelligent multi-provider routing and unbounded context handling",
-      "version": "0.5.0"
+      "description": "Recursive Language Model integration for Claude Code - Go binary hooks (~5ms startup), cross-plugin event coordination (DP/RLM), version-aware config migration, and intelligent multi-provider routing",
+      "version": "0.6.0"
     }
   ]
 }

.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "rlm-claude-code",
   "description": "Recursive Language Model integration for Claude Code - intelligent multi-provider routing and unbounded context handling",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "author": {
     "name": "Rand",
     "url": "https://github.com/rand"

.github/workflows/build-hooks.yml

@@ -0,0 +1,104 @@
+name: Build Hook Binaries
+
+on:
+  push:
+    branches: [main]
+    tags: ['v*']
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: '1.23'
+        cache: true
+
+    - name: Install dependencies
+      run: go mod download
+
+    - name: Run tests
+      run: go test -v -race ./...
+
+    - name: Build all platforms
+      run: |
+        mkdir -p bin
+
+        CMDS="session-init complexity-check trajectory-save"
+
+        for cmd in $CMDS; do
+          [ -d "cmd/$cmd" ] || continue
+
+          echo "Building $cmd..."
+
+          GOOS=darwin GOARCH=arm64 CGO_ENABLED=0 go build -ldflags="-s -w" -trimpath \
+            -o "bin/${cmd}-darwin-arm64" "./cmd/$cmd"
+          GOOS=darwin GOARCH=amd64 CGO_ENABLED=0 go build -ldflags="-s -w" -trimpath \
+            -o "bin/${cmd}-darwin-amd64" "./cmd/$cmd"
+          GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags="-s -w" -trimpath \
+            -o "bin/${cmd}-linux-amd64" "./cmd/$cmd"
+          GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -ldflags="-s -w" -trimpath \
+            -o "bin/${cmd}-linux-arm64" "./cmd/$cmd"
+          GOOS=windows GOARCH=amd64 CGO_ENABLED=0 go build -ldflags="-s -w" -trimpath \
+            -o "bin/${cmd}-windows-amd64.exe" "./cmd/$cmd"
+        done
+
+        ls -la bin/
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: hook-binaries
+        path: bin/
+        retention-days: 7
+
+  release:
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Download artifacts
+      uses: actions/download-artifact@v4
+      with:
+        name: hook-binaries
+        path: bin/
+
+    - name: Create archives
+      run: |
+        VERSION=${GITHUB_REF#refs/tags/}
+        mkdir -p dist
+
+        cd bin
+
+        tar -czvf "../dist/hooks-${VERSION}-darwin-arm64.tar.gz" *-darwin-arm64 2>/dev/null || true
+        tar -czvf "../dist/hooks-${VERSION}-darwin-amd64.tar.gz" *-darwin-amd64 2>/dev/null || true
+        tar -czvf "../dist/hooks-${VERSION}-linux-amd64.tar.gz" *-linux-amd64 2>/dev/null || true
+        tar -czvf "../dist/hooks-${VERSION}-linux-arm64.tar.gz" *-linux-arm64 2>/dev/null || true
+        zip "../dist/hooks-${VERSION}-windows-amd64.zip" *-windows-amd64.exe 2>/dev/null || true
+
+        cd ..
+        ls -la dist/
+
+    - name: Create Release
+      uses: softprops/action-gh-release@v2
+      with:
+        files: dist/*
+        generate_release_notes: true
+        draft: false
+        prerelease: ${{ contains(github.ref, 'alpha') || contains(github.ref, 'beta') || contains(github.ref, 'rc') }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -56,3 +56,6 @@ htmlcov/
 .DS_Store
 Thumbs.db
 .hypothesis/
+
+# Go build output
+bin/

CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+## [0.6.0] - 2026-02-02
+
+### Added
+- Go hook binaries replacing Python scripts (~5ms vs ~500ms startup)
+- Cross-plugin event system (`~/.claude/events/`) for DP↔RLM coordination
+- JSON Schema definitions for all event types
+- Python event emission/consumption helpers (`src/events/`)
+- Version-aware config migration (V1→V2) preserving user customizations
+- Platform-aware hook dispatcher with fallback chain
+- GitHub Actions CI for cross-compilation (5 platforms)
+- Unit tests for hookio, events, and config packages
+
+### Changed
+- **rlm-core enabled by default** (`USE_RLM_CORE=true`) — set `RLM_USE_CORE=false` to disable
+- rlm-core PyO3 bindings now support metadata, provenance, and embedding parameters
+- rlm-core uses separate `-core.db` file to avoid schema conflicts with Python SQLite
+- hooks.json now uses Go binaries + prompt-based hooks
+- Complexity check responds to all DP phases (not just spec/review)
+- RLM orchestrator agent informed about parallel tool call behavior
+- session-init verifies rlm_core is importable on startup
+
+### Fixed
+- Hyperedge queries used `row["type"]` instead of `row["edge_type"]` matching SQLite schema
+
+### Deprecated
+- Python hook scripts moved to `scripts/legacy/`
+- Set `RLM_USE_LEGACY_HOOKS=1` to use legacy Python hooks

Makefile

@@ -0,0 +1,81 @@
+# Makefile for Claude Code plugin hooks
+# Usage:
+#   make dev    - Build for current platform (fast)
+#   make all    - Build for all platforms
+#   make test   - Run tests
+#   make clean  - Remove built binaries
+
+GO := go
+GOFLAGS := -ldflags="-s -w" -trimpath
+
+# Commands to build (add more as you create them)
+CMDS := session-init complexity-check trajectory-save
+
+# Platforms to build for
+PLATFORMS := darwin/arm64 darwin/amd64 linux/amd64 linux/arm64 windows/amd64
+
+.PHONY: all dev clean test lint help
+
+# Default: build for current platform
+dev:
+	@mkdir -p bin
+	@for cmd in $(CMDS); do \
+		if [ -d "cmd/$$cmd" ]; then \
+			echo "Building $$cmd..."; \
+			$(GO) build $(GOFLAGS) -o bin/$$cmd ./cmd/$$cmd; \
+		fi; \
+	done
+	@echo "Built binaries in bin/"
+	@ls -la bin/
+
+# Build for all platforms
+all:
+	@mkdir -p bin
+	@for cmd in $(CMDS); do \
+		if [ -d "cmd/$$cmd" ]; then \
+			echo "Building $$cmd for all platforms..."; \
+			GOOS=darwin GOARCH=arm64 CGO_ENABLED=0 $(GO) build $(GOFLAGS) -o bin/$$cmd-darwin-arm64 ./cmd/$$cmd; \
+			GOOS=darwin GOARCH=amd64 CGO_ENABLED=0 $(GO) build $(GOFLAGS) -o bin/$$cmd-darwin-amd64 ./cmd/$$cmd; \
+			GOOS=linux GOARCH=amd64 CGO_ENABLED=0 $(GO) build $(GOFLAGS) -o bin/$$cmd-linux-amd64 ./cmd/$$cmd; \
+			GOOS=linux GOARCH=arm64 CGO_ENABLED=0 $(GO) build $(GOFLAGS) -o bin/$$cmd-linux-arm64 ./cmd/$$cmd; \
+			GOOS=windows GOARCH=amd64 CGO_ENABLED=0 $(GO) build $(GOFLAGS) -o bin/$$cmd-windows-amd64.exe ./cmd/$$cmd; \
+		fi; \
+	done
+	@echo "Built binaries:"
+	@ls -la bin/
+
+# Run tests
+test:
+	$(GO) test -v -race ./...
+
+# Run linter (requires golangci-lint)
+lint:
+	@command -v golangci-lint >/dev/null 2>&1 || { echo "Install: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest"; exit 1; }
+	golangci-lint run ./...
+
+# Clean build artifacts
+clean:
+	rm -rf bin/
+
+# Install development tools
+install-tools:
+	go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
+
+# Show help
+help:
+	@echo "Available targets:"
+	@echo "  dev          - Build for current platform (fast)"
+	@echo "  all          - Build for all platforms"
+	@echo "  test         - Run tests"
+	@echo "  lint         - Run linter"
+	@echo "  clean        - Remove built binaries"
+	@echo "  install-tools - Install development tools"
+	@echo ""
+	@echo "Commands being built: $(CMDS)"
+	@echo ""
+	@echo "To add a new command, create cmd/<name>/main.go and add to CMDS"
+
+# Quick test of hooks
+test-hooks: dev
+	@echo "Testing session-init..."
+	@echo '{"session_id":"test","source":"startup"}' | HOOK_DEBUG=1 ./bin/session-init || true

README.md

@@ -2,7 +2,7 @@
 
 Transform Claude Code into a Recursive Language Model (RLM) agent with intelligent orchestration, unbounded context handling, persistent memory, and REPL-based decomposition.
 
-**rlm-core integration**: This project optionally uses [rlm-core](https://github.com/rand/loop) as the unified RLM orchestration library, providing shared implementations with [recurse](https://github.com/rand/recurse). When rlm-core is installed and `RLM_USE_CORE=true`, Rust-based pattern classification offers 10-50x faster performance. Falls back to Python when unavailable.
+**rlm-core integration**: This project uses [rlm-core](https://github.com/rand/loop) by default as the unified RLM orchestration library, providing shared implementations with [recurse](https://github.com/rand/recurse). rlm-core provides Rust-based pattern classification (10-50x faster) via PyO3 bindings. Falls back to Python automatically when rlm-core is not installed.
 
 ## What is RLM?
 
@@ -40,9 +40,9 @@ uv sync --all-extras
 uv run pytest tests/ -v
 ```
 
-### Optional: Building rlm-core for Performance
+### Building rlm-core (Enabled by Default)
 
-For 10-50x faster pattern classification, build the [rlm-core](https://github.com/rand/loop) Rust library with Python bindings:
+rlm-core is enabled by default for 10-50x faster pattern classification. Build the [rlm-core](https://github.com/rand/loop) Rust library with Python bindings:
 
 ```bash
 # Clone rlm-core (if not already present)
@@ -103,9 +103,9 @@ cd ~/.claude/plugins/cache/rlm-claude-code/rlm-claude-code/$(ls ~/.claude/plugin
 uv venv && uv sync
 ```
 
-#### Step 3 (Optional): Enable rlm-core for Performance
+#### Step 3: Install rlm-core for Performance (Enabled by Default)
 
-For 10-50x faster pattern classification:
+rlm-core is enabled by default. Install for 10-50x faster pattern classification:
 
 ```bash
 # First, build rlm-core if you haven't already (see "Building rlm-core" section above)
@@ -266,8 +266,8 @@ Add `"use_rlm_core": true` to `~/.claude/rlm-config.json`:
 
 | Setting | Behavior |
 |---------|----------|
-| `use_rlm_core: true` | Use rlm-core Rust bindings (requires installation) |
-| `use_rlm_core: false` or unset | Use Python fallback (default, always works) |
+| `use_rlm_core: true` or unset | Use rlm-core Rust bindings (default, requires installation) |
+| `use_rlm_core: false` | Use Python fallback (always works) |
 
 When rlm-core is enabled but not installed, a warning is logged and Python fallback is used automatically.
 
@@ -277,9 +277,7 @@ When rlm-core is enabled but not installed, a warning is logged and Python fallb
 |-----------|-----------------|---------------|
 | Pattern Classifier | Python regex | Rust via PyO3 (10-50x faster) |
 | Trajectory Events | Python classes | Rust types via PyO3 |
-| Memory Store | Python + SQLite | Python + SQLite (rlm-core memory disabled*) |
-
-*rlm-core memory store integration is disabled pending feature parity (metadata, FTS5 search).
+| Memory Store | Python + SQLite | Python + SQLite primary, rlm-core secondary (`-core.db`) |
 
 ### Benefits of rlm-core
 
@@ -506,7 +504,7 @@ RLM stores configuration at `~/.claude/rlm-config.json`:
 
 | Key | Type | Description |
 |-----|------|-------------|
-| `use_rlm_core` | bool | Enable rlm-core Rust bindings (default: `false`) |
+| `use_rlm_core` | bool | Enable rlm-core Rust bindings (default: `true`) |
 | `activation.mode` | string | `"micro"`, `"complexity"`, `"always"`, `"manual"` |
 | `depth.default` | int | Default recursion depth (1-3) |
 | `trajectory.verbosity` | string | `"minimal"`, `"normal"`, `"verbose"`, `"debug"` |
@@ -525,7 +523,39 @@ RLM stores configuration at `~/.claude/rlm-config.json`:
 
 ## Hooks
 
-RLM integrates with Claude Code via hooks:
+### Go Binary Hooks (v0.6.0+)
+
+As of v0.6.0, RLM uses compiled Go binaries for hook execution, reducing startup latency from ~500ms (Python) to ~5ms. The three primary hooks are:
+
+| Hook | Binary | Purpose |
+|------|--------|---------|
+| `SessionStart` | `session-init` | Initialize RLM environment, emit `session.started` event |
+| `UserPromptSubmit` | `complexity-check` | Decide if RLM should activate, responds to DP phases |
+| `Stop` | `trajectory-save` | Save trajectory and emit `session.ended` event |
+
+Prompt-based hooks (no binary needed) handle context sync, output capture, and pre-compaction.
+
+#### Cross-Plugin Event System
+
+Hooks emit and consume events via `~/.claude/events/`, enabling coordination between plugins (e.g., DP and RLM). All event types have JSON Schema definitions. Python helpers in `src/events/` provide emit/consume APIs.
+
+#### Config Migration
+
+v0.6.0 introduces a V2 config format. Existing V1 configs are automatically migrated on first run, preserving user customizations.
+
+#### Legacy Fallback
+
+To use the original Python hook scripts:
+
+```bash
+export RLM_USE_LEGACY_HOOKS=1
+```
+
+Legacy scripts are located in `scripts/legacy/`.
+
+### Legacy Hook Reference
+
+The original Python hooks (now in `scripts/legacy/`):
 
 | Hook | Script | Purpose |
 |------|--------|---------|

agents/rlm-orchestrator.md

@@ -45,6 +45,19 @@ model = cp.Model([x > 5])
 model.solve()
 ```
 
+## Platform: Parallel Tool Execution
+
+When you issue multiple tool calls in a single message, they run in parallel. If **any one call fails** (non-zero exit code), all sibling calls are cancelled with "Sibling tool call errored" — even if those siblings would have succeeded.
+
+This matters for exploratory Bash calls: commands like `ls`, `grep`, and `find` return **exit code 1** when they find no matches, which is semantically "no results" but triggers sibling cancellation.
+
+When choosing between parallel and sequential tool calls:
+- **Parallel**: when you're confident all calls will succeed (e.g., reading known files, running tested commands)
+- **Sequential**: when calls are exploratory and may legitimately return no results
+- **Guard with `|| true`**: when you want to parallelize uncertain commands without risking cascade failure
+
+Prefer Glob and Grep tools over Bash `find`/`grep` for file discovery — they handle no-results gracefully without non-zero exit codes.
+
 ## Rules
 
 1. **Don't request full context dumps** — Use programmatic access