feat: initial Parallax workspace scaffold

- 9 crates: core, store, graph, query, policy, ingest, connect, server, cli
- parallax-core: EntityId, Entity, Relationship, Value, Timestamp, SourceTag
- 15 passing tests in parallax-core
- 9 architectural specs (00-vision through 08-policy-engine)
- CLAUDE.md with YOLO + strict gitflow workflow modes
- .claude/commands for dev automation
- GitHub Actions CI (check, fmt, clippy, test)

Author: copyleftdev

.claude/commands/build.md

@@ -0,0 +1,21 @@
+---
+description: Build the entire workspace or a specific crate
+---
+
+Build the Parallax workspace.
+
+If the user specifies a crate name (e.g., "store", "graph", "query"), build only that crate:
+```bash
+cargo build --package parallax-$CRATE_NAME
+```
+
+Otherwise build the full workspace:
+```bash
+cargo build --workspace
+```
+
+// turbo
+After the build, report:
+1. Whether it succeeded or failed
+2. Any warnings (summarize, don't dump raw output)
+3. If failed, identify the root error and suggest a fix

.claude/commands/check.md

@@ -0,0 +1,28 @@
+---
+description: Run full CI checks (clippy, fmt, test) like a pre-push gate
+---
+
+Run the full Parallax CI check suite in order. Stop on first failure.
+
+// turbo
+1. Format check:
+```bash
+cargo fmt --all -- --check
+```
+
+// turbo
+2. Clippy lint:
+```bash
+cargo clippy --workspace --all-targets -- -D warnings
+```
+
+// turbo
+3. Tests:
+```bash
+cargo test --workspace
+```
+
+After all steps, report a summary:
+- ✓ or ✗ for each step
+- Total time elapsed
+- If any step failed, show the root cause and suggest a fix

.claude/commands/feat.md

@@ -0,0 +1,40 @@
+---
+description: Start a new feature branch (strict gitflow mode) with conventional commit setup
+---
+
+Create a feature branch for a new piece of work. Strict gitflow mode only.
+
+The user specifies type and name, e.g.:
+- `feat wal-group-commit`
+- `fix cyclic-traversal`
+- `refactor planner-cost-model`
+
+Steps:
+
+1. Verify we're on `develop` (or create it from `main` if it doesn't exist)
+
+```bash
+git checkout develop 2>/dev/null || git checkout -b develop
+```
+
+2. Pull latest
+
+```bash
+git pull --rebase origin develop 2>/dev/null || true
+```
+
+3. Create the feature branch
+
+```bash
+git checkout -b <type>/<name>
+```
+
+4. Report the branch name and remind the user of the conventional commit format:
+
+```
+<type>(<scope>): <description>
+```
+
+Valid scopes: core, store, graph, query, policy, ingest, connect, server, cli
+
+5. When done, the user should run `/pr` to create the PR checklist.

.claude/commands/impl.md

@@ -0,0 +1,36 @@
+---
+description: Implement a type or function from a spec, following all architectural constraints
+---
+
+Implement a specific type, trait, or function from the Parallax specs.
+
+The user will say something like:
+- `impl EntityId` → implement the EntityId type from spec 01
+- `impl WAL append` → implement the WAL append method from spec 02
+- `impl BFS traversal` → implement the BFS traversal from spec 03
+- `impl PQL parser` → implement the PQL lexer+parser from spec 04
+
+Steps:
+
+1. Read the relevant spec file to get the type signature, invariants, and design constraints.
+2. Read the target crate's existing code to understand what already exists.
+3. Implement the type/function following:
+   - Exact type signatures from the spec (they are the contract)
+   - Ownership patterns described in the spec (Matsakis's rules)
+   - Error handling: `thiserror` in libraries, propagate with `?`
+   - No `unwrap()` — use `expect("reason")` or `?`
+   - Every `unsafe` block gets a `// SAFETY:` comment
+   - Add `#[cfg(test)] mod tests` with at least one happy-path and one error-path test
+4. After implementation:
+
+// turbo
+```bash
+cargo check --package parallax-<crate>
+```
+
+// turbo
+```bash
+cargo test --package parallax-<crate>
+```
+
+5. Report which invariants (INV-*) are covered by the implementation and tests.

.claude/commands/invariants.md

@@ -0,0 +1,17 @@
+---
+description: List all invariants or check which invariants a code change affects
+---
+
+Two modes:
+
+**List all:** `invariants list`
+- Read all spec files (00-08) and extract every `INV-*` code
+- Display as a table: Code | Spec | Description
+
+**Check impact:** `invariants check <file_or_crate>`
+- Read the specified file or all files in the specified crate
+- Cross-reference against the invariant list
+- Report which invariants the code touches or could violate
+- Flag any potential violations with specific line numbers
+
+This is the pre-commit safety check. Run it before any PR in strict gitflow mode.

.claude/commands/pr.md

@@ -0,0 +1,80 @@
+---
+description: Generate a PR description and run the pre-merge checklist (strict gitflow)
+---
+
+Generate a pull request for the current feature branch. Strict gitflow mode.
+
+Steps:
+
+1. Get the current branch name and diff against develop:
+
+```bash
+git branch --show-current
+```
+
+```bash
+git log develop..HEAD --oneline
+```
+
+```bash
+git diff develop --stat
+```
+
+2. Run the full CI check suite (same as /check):
+
+// turbo
+```bash
+cargo fmt --all -- --check
+```
+
+// turbo
+```bash
+cargo clippy --workspace --all-targets -- -D warnings
+```
+
+// turbo
+```bash
+cargo test --workspace
+```
+
+3. Check for forbidden patterns:
+
+```bash
+grep -rn "unwrap()" crates/ --include="*.rs" | grep -v "test" | grep -v "#\[cfg(test)\]" || echo "No unwrap() in library code"
+```
+
+```bash
+grep -rn "TODO(yolo)" crates/ connectors/ --include="*.rs" || echo "No TODO(yolo) markers"
+```
+
+4. Generate the PR description in this format:
+
+```markdown
+## Summary
+<one paragraph describing the change>
+
+## Type
+<feat|fix|refactor|perf|test|docs|ci|chore>(<scope>)
+
+## Changes
+<bulleted list of files changed and what changed in each>
+
+## Invariants
+<list any INV-* codes affected by this change>
+
+## Checklist
+- [ ] Branch is up to date with `develop`
+- [ ] `cargo check --workspace` passes
+- [ ] `cargo test --workspace` passes
+- [ ] `cargo clippy --workspace --all-targets -- -D warnings` passes
+- [ ] `cargo fmt --all -- --check` passes
+- [ ] New public APIs have doc comments
+- [ ] Invariants from specs are preserved
+- [ ] No `unwrap()` in library crates
+- [ ] No `TODO(yolo)` markers remain
+
+## Testing
+<describe what was tested and how>
+```
+
+5. Report pass/fail status for each checklist item.

.claude/commands/scaffold.md

@@ -0,0 +1,26 @@
+---
+description: Scaffold a new crate or connector with correct structure
+---
+
+Scaffold a new Parallax component. The user will specify one of:
+
+**Crate:** `scaffold crate <name>`
+- Create `crates/parallax-<name>/Cargo.toml` with workspace dependency on `parallax-core`
+- Create `crates/parallax-<name>/src/lib.rs` with module doc comment and basic structure
+- Add the crate to the workspace `Cargo.toml` members list
+- Follow the dependency rules from `specs/07-crate-structure.md` — never create upward dependencies
+
+**Connector:** `scaffold connector <source>`
+- Create `connectors/connector-<source>/Cargo.toml` depending on `parallax-connect`
+- Create `connectors/connector-<source>/src/lib.rs` implementing the `Connector` trait skeleton
+- Include one example step with TODO markers
+- Add to workspace members
+
+For both, after scaffolding:
+
+// turbo
+```bash
+cargo check --workspace
+```
+
+Report what was created and confirm it compiles.

.claude/commands/spec.md

@@ -0,0 +1,16 @@
+---
+description: Look up a spec by number or keyword and summarize relevant sections
+---
+
+Read and summarize a Parallax spec. The user will specify either:
+
+- A spec number: `spec 02` → read `specs/02-storage-engine.md`
+- A keyword: `spec traversal` → find the most relevant spec and section
+
+Read the spec file and provide:
+1. A one-paragraph summary of the spec's purpose
+2. The key invariants (INV-* codes) defined in the spec
+3. The open questions listed at the end
+4. Any code types/signatures relevant to the user's current work
+
+If the user asks about a specific topic (e.g., "spec MVCC"), search across all specs for the relevant sections rather than reading a single file end-to-end.

.claude/commands/yolo.md

@@ -0,0 +1,20 @@
+---
+description: Quick commit in YOLO mode — add all, commit with message, no ceremony
+---
+
+Fast commit for YOLO mode. The user provides a short message.
+
+// turbo
+```bash
+cargo check --workspace
+```
+
+If check passes:
+
+```bash
+git add -A && git commit -m "$ARGUMENTS"
+```
+
+If check fails, fix the error first, then commit.
+
+Never run this in strict gitflow mode. Check CLAUDE.md for active mode.

.claude/settings.json

@@ -0,0 +1,38 @@
+{
+  "permissions": {
+    "allow": [
+      "cargo build*",
+      "cargo check*",
+      "cargo test*",
+      "cargo clippy*",
+      "cargo fmt*",
+      "cargo bench*",
+      "cargo doc*",
+      "cargo run --package parallax-cli*",
+      "cargo tree*",
+      "cargo metadata*",
+      "rg *",
+      "fd *",
+      "cat *",
+      "head *",
+      "tail *",
+      "wc *",
+      "git status",
+      "git log*",
+      "git diff*",
+      "git branch*",
+      "git show*",
+      "git stash list"
+    ],
+    "deny": [
+      "rm -rf /",
+      "cargo publish*",
+      "git push --force*",
+      "git reset --hard*",
+      "sudo *"
+    ]
+  },
+  "model": {
+    "temperature": 0
+  }
+}