feat(compute): Extract OpenCL compute infrastructure from ART (#3)

* feat: add PM infrastructure and beads for OpenCL extraction

- Add .pm/ project management infrastructure
  - CONTINUATION.md for session resumption
  - METHODOLOGY.md for TDD workflow
  - CONTEXT_PROTOCOL.md for agent handoffs
- Add .beads/ for issue tracking with beads
- Add AGENTS.md with bd commands reference
- Create bead hierarchy for 4-phase OpenCL extraction:
  - Phase 1: Core interfaces (GPUBuffer, ComputeKernel)
  - Phase 2: OpenCL implementation
  - Phase 3: Utilities and stubs
  - Phase 4: ART migration

Plan v2 audited and approved (92% confidence GO).
See ChromaDB: plan::gpu-support::art-opencl-extraction::v2

* feat(compute): Phase 1 - extract core compute interfaces from ART

Extract portable compute API layer (Layer 2 per architecture decision):

- GPUBuffer: Host-device memory transfer interface
- ComputeKernel: Unified kernel compilation/execution interface
  - BufferAccess enum for kernel argument modes
  - KernelCompilationException, KernelExecutionException
- GPUBackend: Enum for METAL, OPENCL, CPU_FALLBACK with priorities
- GPUErrorClassifier: Programming vs recoverable error classification
  - OpenCL error code extraction from exception messages
  - Fixed self-referencing cause infinite loop (improvement over ART)

All interfaces are backend-agnostic. OpenCL implementations (Layer 3)
will wrap existing CLKernelHandle/CLBufferHandle (Layer 1) in Phase 2.

Beads closed: e63, ad2, kdp, ipz, 6e9
See: plan::gpu-support::art-opencl-extraction::v2

* Phase 2 progress: OpenCLContext, OpenCLBuffer, GPUBackend.isAvailable()

- Extract OpenCLContext singleton with reference counting and testReset()
- Extract OpenCLBuffer implementing GPUBuffer interface
- Add GPUBackend.isAvailable() with cached Metal/OpenCL detection
- Remove CL.create() calls to avoid macOS SIGSEGV in forked JVMs
- Add dual property name support (gpu.disable, luciferase.gpu.disable)

Beads: gij, 9go closed; ilr in progress

Note: OpenCLBufferTest has macOS driver crash - needs debugging

* Fix OpenCLBufferTest SIGSEGV crash on macOS

Replace JUnit Assumptions.assumeTrue() pattern with simple early-return
checks in each test method. The Assumptions pattern caused OpenCL driver
state issues in Maven Surefire forked JVM processes.

- Simplified @BeforeAll to just detect OpenCL availability
- Use `if (!openCLAvailable) return;` instead of @beforeeach assumptions
- Fix IndexOutOfBounds in FloatBuffer test (remove unnecessary flip())
- All 10 OpenCLBuffer tests pass

Closes: gpu-support-ilr

* feat(compute): Extract OpenCLKernel from ART

Implement OpenCLKernel as ComputeKernel interface for GPU compute:
- Kernel compilation with build log on failure
- Buffer, float, int, and local memory argument binding
- 1D/2D/3D execution with optional local work sizes
- Async execution with event-based synchronization
- Uses OpenCLContext singleton pattern

16 tests covering:
- Compilation lifecycle (compile, double-compile, invalid source)
- Argument setting (buffer, scalar, before compile)
- Execution (vectorAdd, scale, 2D/3D work sizes)
- Resource lifecycle (close, double-close, ops after close)

Closes: gpu-support-6pw

* feat(compute): Extract BackendSelector with dual env var support

Automatic GPU backend selection with priority-based fallback:
- Metal (priority 100, macOS only)
- OpenCL (priority 90, cross-platform)
- CPU fallback (priority 10, always available)

Environment variable support:
- GPU_BACKEND / GPU_DISABLE (new generic names)
- ART_GPU_BACKEND / ART_GPU_DISABLE (legacy, deprecated)

CI environment auto-detection (GitHub Actions, Jenkins, etc).

17 tests covering selection logic, caching, and environment info.

Closes: gpu-support-cbr

* test(compute): Add Phase 2 integration tests

Full compute workflow tests:
- vectorAdd: context → buffers → kernel → execute → read
- SAXPY: scalar float arguments (result = a*x + y)
- 2D execution: proper 2D kernel indexing
- Large data: 64K elements
- Multiple executions: iterative kernel runs
- Resource cleanup: try-with-resources pattern

9 integration tests verifying complete OpenCL compute pipeline.

Closes: gpu-support-97u

* Close Phase 2 feature bead (5wc)

* feat(compute): Add KernelLoader with path conventions

Kernel loading utility with caching and convention support:
- loadOpenCLKernel(name) → kernels/opencl/{name}.cl
- loadMetalKernel(name) → kernels/metal/{name}.metal
- loadTestKernel(name) → kernels/{name}.cl (flat structure)
- ConcurrentHashMap caching for repeated loads
- kernelExists() for resource checking

Package documentation with usage examples and conventions.

12 tests covering loading, caching, and error handling.

Closes: gpu-support-0y1

* Close extraction epic (bsy) - gpu-support extraction complete

* fix: Add .pm/ to gitignore and remove from tracking

* feat(compute): add high-level ComputeService API with example kernels

Add ComputeService facade providing simplified GPU compute with automatic
CPU fallback. Includes built-in operations for vector math (vectorAdd,
saxpy, scale) and reductions (sum, min, max), plus custom operation
support via createOperation().

New resources:
- kernels/opencl/vector_add.cl - element-wise vector addition
- kernels/opencl/saxpy.cl - SAXPY operations
- kernels/opencl/reduce.cl - parallel sum/min/max reductions
- kernels/opencl/transform.cl - scale, clamp, abs, square, sqrt

Tests:
- ComputeServiceTest: 16 tests demonstrating API usage
- ComputeServiceStressTest: 23 tests for edge cases, large arrays,
  concurrent access, and memory pressure

Total: 302 tests pass in resource module

* docs(compute): add usage guide and runnable examples

COMPUTE.md covers:
- Basic operations (vectorAdd, saxpy, scale, sum, min, max)
- Custom kernel writing
- Low-level API usage
- Configuration (env vars, backend selection)
- Error handling
- Performance notes
- Thread safety

Examples in examples/ package:
- VectorMathExample: built-in operations
- CustomKernelExample: writing custom kernels
- PerformanceExample: GPU vs CPU timing
- LowLevelExample: direct buffer/kernel control

* docs: add GPU compute section to root README

* fix(gpu-test): correct kernel argument passing in SimpleMatrixMultiplyTest

Bug: stack.ints(N) allocates N zero-filled ints, not an int containing N.
The kernel received size=0, producing all zeros.

Fix: Use clSetKernelArg1i/clSetKernelArg1p for scalar and pointer args.

* docs: add GPU compute API reference to AGENTS.md for AI discovery

Author: Hellblazer

.beads/.gitignore

@@ -0,0 +1,32 @@
+# SQLite databases
+*.db
+*.db?*
+*.db-journal
+*.db-wal
+*.db-shm
+
+# Daemon runtime files
+daemon.lock
+daemon.log
+daemon.pid
+bd.sock
+
+# Local version tracking (prevents upgrade notification spam after git ops)
+.local_version
+
+# Legacy database files
+db.sqlite
+bd.db
+
+# Merge artifacts (temporary files from 3-way merge)
+beads.base.jsonl
+beads.base.meta.json
+beads.left.jsonl
+beads.left.meta.json
+beads.right.jsonl
+beads.right.meta.json
+
+# Keep JSONL exports and config (source of truth for git)
+!issues.jsonl
+!metadata.json
+!config.json

.beads/README.md

@@ -0,0 +1,81 @@
+# Beads - AI-Native Issue Tracking
+
+Welcome to Beads! This repository uses **Beads** for issue tracking - a modern, AI-native tool designed to live directly in your codebase alongside your code.
+
+## What is Beads?
+
+Beads is issue tracking that lives in your repo, making it perfect for AI coding agents and developers who want their issues close to their code. No web UI required - everything works through the CLI and integrates seamlessly with git.
+
+**Learn more:** [github.com/steveyegge/beads](https://github.com/steveyegge/beads)
+
+## Quick Start
+
+### Essential Commands
+
+```bash
+# Create new issues
+bd create "Add user authentication"
+
+# View all issues
+bd list
+
+# View issue details
+bd show <issue-id>
+
+# Update issue status
+bd update <issue-id> --status in_progress
+bd update <issue-id> --status done
+
+# Sync with git remote
+bd sync
+```
+
+### Working with Issues
+
+Issues in Beads are:
+- **Git-native**: Stored in `.beads/issues.jsonl` and synced like code
+- **AI-friendly**: CLI-first design works perfectly with AI coding agents
+- **Branch-aware**: Issues can follow your branch workflow
+- **Always in sync**: Auto-syncs with your commits
+
+## Why Beads?
+
+✨ **AI-Native Design**
+- Built specifically for AI-assisted development workflows
+- CLI-first interface works seamlessly with AI coding agents
+- No context switching to web UIs
+
+🚀 **Developer Focused**
+- Issues live in your repo, right next to your code
+- Works offline, syncs when you push
+- Fast, lightweight, and stays out of your way
+
+🔧 **Git Integration**
+- Automatic sync with git commits
+- Branch-aware issue tracking
+- Intelligent JSONL merge resolution
+
+## Get Started with Beads
+
+Try Beads in your own projects:
+
+```bash
+# Install Beads
+curl -sSL https://raw.githubusercontent.com/steveyegge/beads/main/scripts/install.sh | bash
+
+# Initialize in your repo
+bd init
+
+# Create your first issue
+bd create "Try out Beads"
+```
+
+## Learn More
+
+- **Documentation**: [github.com/steveyegge/beads/docs](https://github.com/steveyegge/beads/tree/main/docs)
+- **Quick Start Guide**: Run `bd quickstart`
+- **Examples**: [github.com/steveyegge/beads/examples](https://github.com/steveyegge/beads/tree/main/examples)
+
+---
+
+*Beads: Issue tracking that moves at the speed of thought* ⚡

.beads/config.yaml

@@ -0,0 +1,62 @@
+# Beads Configuration File
+# This file configures default behavior for all bd commands in this repository
+# All settings can also be set via environment variables (BD_* prefix)
+# or overridden with command-line flags
+
+# Issue prefix for this repository (used by bd init)
+# If not set, bd init will auto-detect from directory name
+# Example: issue-prefix: "myproject" creates issues like "myproject-1", "myproject-2", etc.
+# issue-prefix: ""
+
+# Use no-db mode: load from JSONL, no SQLite, write back after each command
+# When true, bd will use .beads/issues.jsonl as the source of truth
+# instead of SQLite database
+# no-db: false
+
+# Disable daemon for RPC communication (forces direct database access)
+# no-daemon: false
+
+# Disable auto-flush of database to JSONL after mutations
+# no-auto-flush: false
+
+# Disable auto-import from JSONL when it's newer than database
+# no-auto-import: false
+
+# Enable JSON output by default
+# json: false
+
+# Default actor for audit trails (overridden by BD_ACTOR or --actor)
+# actor: ""
+
+# Path to database (overridden by BEADS_DB or --db)
+# db: ""
+
+# Auto-start daemon if not running (can also use BEADS_AUTO_START_DAEMON)
+# auto-start-daemon: true
+
+# Debounce interval for auto-flush (can also use BEADS_FLUSH_DEBOUNCE)
+# flush-debounce: "5s"
+
+# Git branch for beads commits (bd sync will commit to this branch)
+# IMPORTANT: Set this for team projects so all clones use the same sync branch.
+# This setting persists across clones (unlike database config which is gitignored).
+# Can also use BEADS_SYNC_BRANCH env var for local override.
+# If not set, bd sync will require you to run 'bd config set sync.branch <branch>'.
+# sync-branch: "beads-sync"
+
+# Multi-repo configuration (experimental - bd-307)
+# Allows hydrating from multiple repositories and routing writes to the correct JSONL
+# repos:
+#   primary: "."  # Primary repo (where this database lives)
+#   additional:   # Additional repos to hydrate from (read-only)
+#     - ~/beads-planning  # Personal planning repo
+#     - ~/work-planning   # Work planning repo
+
+# Integration settings (access with 'bd config get/set')
+# These are stored in the database, not in this file:
+# - jira.url
+# - jira.project
+# - linear.url
+# - linear.api-key
+# - github.org
+# - github.repo