igniter 0.3.1 → 0.4.3

data/README.md

@@ -2,19 +2,17 @@
 
 Igniter is a Ruby gem for expressing business logic as a validated dependency graph and executing that graph with:
 
-- lazy output resolution
-- selective invalidation after input updates
-- typed input validation
-- nested contract composition
-- runtime auditing
-- diagnostics reports
-- reactive side effects
-- ergonomic DSL helpers (`with`, `const`, `lookup`, `map`, `project`, `aggregate`, `guard`, `export`, `expose`, `effect`, `on_success`, `scope`, `namespace`, `branch`, `collection`)
-- graph and runtime introspection
-- async-capable pending nodes with snapshot/restore
-- store-backed execution resume flows
-
-The repository now contains a working v2 core built around explicit compile-time and runtime boundaries.
+- lazy output resolution and selective cache invalidation
+- typed input validation with defaults and required fields
+- nested contract composition with isolated child executions
+- declarative routing (`branch`) and fan-out (`collection`)
+- distributed workflows: `await` events across process boundaries
+- multi-node deployments via `igniter-server` and the `remote:` DSL
+- LLM compute nodes with Ollama, Anthropic, and OpenAI providers
+- Rails integration: ActiveJob, ActionCable, webhook handlers, generators
+- runtime auditing, diagnostics reports, and reactive side effects
+- graph and runtime introspection (text, Mermaid)
+- ergonomic DSL helpers: `const`, `lookup`, `map`, `project`, `aggregate`, `guard`, `export`, `expose`, `effect`, `on_success`, `scope`, `namespace`
 
 ## Installation
 
@@ -30,8 +28,8 @@ require "igniter"
 class PriceContract < Igniter::Contract
   define do
     input :order_total, type: :numeric
-    input :country, type: :string
-    input :vat_rate, type: :numeric, default: 0.2
+    input :country,     type: :string
+    input :vat_rate,    type: :numeric, default: 0.2
 
     compute :effective_vat_rate, depends_on: %i[country vat_rate] do |country:, vat_rate:|
       country == "UA" ? vat_rate : 0.0
@@ -46,51 +44,36 @@ class PriceContract < Igniter::Contract
 end
 
 contract = PriceContract.new(order_total: 100, country: "UA")
-
-contract.result.gross_total
-# => 120.0
+contract.result.gross_total   # => 120.0
 
 contract.update_inputs(order_total: 150)
-contract.result.gross_total
-# => 180.0
+contract.result.gross_total   # => 180.0
 
-contract.diagnostics_text
-# => compact execution summary
+contract.diagnostics_text     # compact execution summary
 ```
 
 ## Features
 
-- Contracts: declare inputs, compute nodes, outputs, and compositions.
-- Compiler: validate dependency graphs before runtime.
-- Runtime: cache resolved nodes and invalidate only affected downstream nodes.
-- Typed inputs: validate types, defaults, and required fields.
-- Composition: execute nested contracts with isolated child executions.
-- Auditing: collect execution timelines and snapshots.
-- Diagnostics: build compact text, markdown, or structured reports for triage.
-- Reactive: subscribe declaratively to runtime events.
-- Introspection: render graphs as text or Mermaid and inspect runtime state.
-- Ergonomics: use compact DSL helpers for common lookup, transform, guard, export, and side-effect patterns.
+- **Contracts**: declare inputs, compute nodes, outputs, and compositions in a validated graph.
+- **Compiler**: validate dependency graphs, types, and cycles before runtime; errors are surfaced at load time.
+- **Runtime**: cache resolved nodes and invalidate only affected downstream nodes on input change.
+- **Typed inputs**: validate types, defaults, and required fields at execution boundaries.
+- **Composition**: execute nested contracts with isolated child executions.
+- **Branch**: declarative routing — select one child contract from ordered cases at runtime.
+- **Collection**: declarative fan-out — run one child contract per item in an array.
+- **Distributed workflows**: `await` external events; resume via `deliver_event`.
+- **igniter-server**: host contracts as a TCP/Rack HTTP service; call remote contracts with the `remote:` DSL.
+- **LLM integration**: compute nodes powered by Ollama, Anthropic, or OpenAI providers.
+- **Rails integration**: Railtie, ActiveJob base class, ActionCable adapter, webhook controller mixin.
+- **Auditing**: collect execution timelines and snapshots.
+- **Diagnostics**: compact text, Markdown, or structured reports for triage.
+- **Reactive**: subscribe declaratively to runtime events with `effect`, `on_success`, `on_failure`.
+- **Introspection**: render graphs as text or Mermaid; inspect runtime state.
 
 ## Quick Start Recipes
 
-The repository contains runnable examples in [`examples/`](examples).
-They also have matching specs, so they stay in sync with the implementation.
-The examples folder also has its own quick index in [`examples/README.md`](examples/README.md).
-There is also a short patterns guide in [`docs/PATTERNS.md`](docs/PATTERNS.md).
-
-| Example | Run | Shows |
-| --- | --- | --- |
-| `basic_pricing.rb` | `ruby examples/basic_pricing.rb` | basic contract, lazy resolution, input updates |
-| `composition.rb` | `ruby examples/composition.rb` | nested contracts and composed results |
-| `diagnostics.rb` | `ruby examples/diagnostics.rb` | diagnostics text plus machine-readable output |
-| `async_store.rb` | `ruby examples/async_store.rb` | pending execution, file-backed store, worker-style resume |
-| `marketing_ergonomics.rb` | `ruby examples/marketing_ergonomics.rb` | compact domain DSL with `with`, matcher-style `guard`, `scope`/`namespace`, `expose`, `on_success`, and `explain_plan` |
-| `collection.rb` | `ruby examples/collection.rb` | declarative fan-out, stable item keys, and `CollectionResult` |
-| `collection_partial_failure.rb` | `ruby examples/collection_partial_failure.rb` | `:collect` mode, partial failure summary, and collection diagnostics |
-| `ringcentral_routing.rb` | `ruby examples/ringcentral_routing.rb` | top-level `branch`, nested `collection`, `project`, `aggregate`, `using:`/`map_inputs`, and nested diagnostics semantics |
-
-There are also matching living examples in `spec/igniter/examples_spec.rb`.
-Those are useful if you want to read the examples in test form.
+Runnable examples live in [`examples/`](examples) and are smoke-tested by `spec/igniter/example_scripts_spec.rb`.
+See [`examples/README.md`](examples/README.md) for a quick index and [`docs/PATTERNS.md`](docs/PATTERNS.md) for composable patterns.
 
 ### 1. Basic Pricing Contract
 
@@ -98,7 +81,7 @@ Those are useful if you want to read the examples in test form.
 class PriceContract < Igniter::Contract
   define do
     input :order_total, type: :numeric
-    input :country, type: :string
+    input :country,     type: :string
 
     compute :vat_rate, depends_on: [:country] do |country:|
       country == "UA" ? 0.2 : 0.0
@@ -122,11 +105,11 @@ PriceContract.new(order_total: 100, country: "UA").result.gross_total
 class CheckoutContract < Igniter::Contract
   define do
     input :order_total, type: :numeric
-    input :country, type: :string
+    input :country,     type: :string
 
     compose :pricing, contract: PriceContract, inputs: {
       order_total: :order_total,
-      country: :country
+      country:     :country
     }
 
     output :pricing
@@ -137,7 +120,7 @@ CheckoutContract.new(order_total: 100, country: "UA").result.pricing.gross_total
 # => 120.0
 ```
 
-### 3. Diagnostics And Introspection
+### 3. Diagnostics and Introspection
 
 ```ruby
 contract = PriceContract.new(order_total: 100, country: "UA")
@@ -149,28 +132,24 @@ contract.diagnostics.to_h
 contract.diagnostics_text
 contract.diagnostics_markdown
 contract.audit_snapshot
+
+PriceContract.graph.to_text
+PriceContract.graph.to_mermaid
 ```
 
 ### 4. Machine-Readable Data
 
 ```ruby
-contract = PriceContract.new(order_total: 100, country: "UA")
-contract.result.gross_total
-
-contract.result.to_h
-# => { gross_total: 120.0 }
-
+contract.result.to_h       # => { gross_total: 120.0 }
 contract.result.as_json
 contract.execution.as_json
 contract.events.map(&:as_json)
 ```
 
-### 5. Async Store And Resume
+### 5. Async Store and Resume
 
 ```ruby
 class AsyncQuoteExecutor < Igniter::Executor
-  input :order_total, type: :numeric
-
   def call(order_total:)
     defer(token: "quote-#{order_total}", payload: { kind: "pricing_quote" })
   end
@@ -181,29 +160,22 @@ class AsyncPricingContract < Igniter::Contract
 
   define do
     input :order_total, type: :numeric
-
     compute :quote_total, depends_on: [:order_total], call: AsyncQuoteExecutor
-
     compute :gross_total, depends_on: [:quote_total] do |quote_total:|
       quote_total * 1.2
     end
-
     output :gross_total
   end
 end
 
-contract = AsyncPricingContract.new(order_total: 100)
-deferred = contract.result.gross_total
+contract     = AsyncPricingContract.new(order_total: 100)
+deferred     = contract.result.gross_total
 execution_id = contract.execution.events.execution_id
 
 resumed = AsyncPricingContract.resume_from_store(
-  execution_id,
-  token: deferred.token,
-  value: 150
+  execution_id, token: deferred.token, value: 150
 )
-
-resumed.result.gross_total
-# => 180.0
+resumed.result.gross_total  # => 180.0
 ```
 
 ### 6. Ergonomic DSL
@@ -211,14 +183,14 @@ resumed.result.gross_total
 ```ruby
 class MarketingQuoteContract < Igniter::Contract
   define do
-    input :service, type: :string
+    input :service,  type: :string
     input :zip_code, type: :string
 
     const :vendor_id, "eLocal"
 
     scope :routing do
       map :trade_name, from: :service do |service:|
-        %w[heating cooling ventilation air_conditioning].include?(service.downcase) ? "HVAC" : service
+        %w[heating cooling ventilation].include?(service.downcase) ? "HVAC" : service
       end
     end
 
@@ -232,7 +204,7 @@ class MarketingQuoteContract < Igniter::Contract
       guard :zip_supported, with: :zip_code, in: %w[60601 10001], message: "Unsupported zip"
     end
 
-    compute :quote, with: %i[vendor_id trade zip_supported zip_code] do |vendor_id:, trade:, zip_supported:, zip_code:|
+    compute :quote, with: %i[vendor_id trade zip_code zip_supported] do |vendor_id:, trade:, zip_code:, zip_supported:|
       zip_supported
       { vendor_id: vendor_id, trade: trade[:name], zip_code: zip_code, bid: trade[:base_bid] }
     end
@@ -244,19 +216,14 @@ class MarketingQuoteContract < Igniter::Contract
     puts "Persist #{value.inspect}"
   end
 end
-
-contract = MarketingQuoteContract.new(service: "heating", zip_code: "60601")
-
-contract.explain_plan
-contract.result.response
 ```
 
-You can also use matcher-style guards directly:
+Matcher-style guard shortcuts:
 
 ```ruby
-guard :usa_only, with: :country_code, eq: "USA", message: "Unsupported country"
-guard :supported_country, with: :country_code, in: %w[USA CAN], message: "Unsupported country"
-guard :valid_zip, with: :zip_code, matches: /\A\d{5}\z/, message: "Invalid zip"
+guard :usa_only,          with: :country_code, eq: "USA",            message: "Unsupported country"
+guard :supported_country, with: :country_code, in: %w[USA CAN],      message: "Unsupported country"
+guard :valid_zip,         with: :zip_code,     matches: /\A\d{5}\z/, message: "Invalid zip"
 ```
 
 ### 7. Declarative Branching
@@ -268,12 +235,12 @@ class DeliveryContract < Igniter::Contract
     input :order_total
 
     branch :delivery_strategy, with: :country, inputs: {
-      country: :country,
+      country:     :country,
       order_total: :order_total
     } do
       on "US", contract: USDeliveryContract
       on "UA", contract: LocalDeliveryContract
-      default contract: DefaultDeliveryContract
+      default   contract: DefaultDeliveryContract
     end
 
     export :price, :eta, from: :delivery_strategy
@@ -281,163 +248,225 @@ class DeliveryContract < Igniter::Contract
 end
 ```
 
-### 8. Branch + Collection Routing
+### 8. Declarative Collections
 
 ```ruby
-class RingcentralWebhookContract < Igniter::Contract
+class TechnicianBatchContract < Igniter::Contract
   define do
-    input :payload
-
-    scope :parse do
-      map :body, from: :payload do |payload:|
-        payload.fetch("body", {})
-      end
-
-      map :telephony_status, from: :body do |body:|
-        body["telephonyStatus"]
-      end
-
-      map :active_calls, from: :body do |body:|
-        body["activeCalls"] || []
-      end
-    end
+    input :technician_inputs, type: :array
 
-    branch :status_route, with: :telephony_status, inputs: {
-      extension_id: :extension_id,
-      telephony_status: :telephony_status,
-      active_calls: :active_calls
-    } do
-      on "CallConnected", contract: CallConnectedContract
-      on "NoCall", contract: NoCallContract
-      default contract: UnknownStatusContract
-    end
+    collection :technicians,
+               with: :technician_inputs,
+               each: TechnicianContract,
+               key:  :technician_id,
+               mode: :collect
 
-    export :routing_summary, from: :status_route
+    output :technicians
   end
 end
 ```
 
-In nested flows, diagnostics stay attached to the execution that actually owns the node:
+In `mode: :collect`, an execution succeeds overall while items may individually fail:
 
-- the parent execution sees the top-level `branch_selected`
-- collection item events live on the selected child execution
-- collection summaries are easiest to read from the child contract diagnostics
+- `result.summary`       — collection-level status (`:partial_failure` when any item failed)
+- `result.items_summary` — compact per-item status hash
+- `result.failed_items`  — failed-item error details
+- `result.successes`     — hash of succeeded items only
 
-`branch` is a graph primitive for explicit routing. It selects one child contract from ordered cases and resolves only the chosen branch.
+See [`examples/collection_partial_failure.rb`](examples/collection_partial_failure.rb).
 
-### 8. Declarative Collections
+### 9. Distributed Contracts
+
+Use `await` to suspend execution until an external event arrives. `correlate_by` identifies
+which execution should receive the event, so events can be delivered from any process:
 
 ```ruby
-class TechnicianBatchContract < Igniter::Contract
+class LeadWorkflow < Igniter::Contract
+  correlate_by :request_id
+
   define do
-    input :technician_inputs, type: :array
+    input :request_id
 
-    collection :technicians,
-      with: :technician_inputs,
-      each: TechnicianContract,
-      key: :technician_id,
-      mode: :collect
+    await :crm_data,     event: :crm_received
+    await :billing_data, event: :billing_received
 
-    output :technicians
+    aggregate :report, with: %i[crm_data billing_data] do |crm_data:, billing_data:|
+      { crm: crm_data, billing: billing_data }
+    end
+
+    output :report
+  end
+
+  on_success :report do |value:, **|
+    puts "Report ready: #{value.inspect}"
   end
 end
-```
 
-`collection` is a graph primitive for explicit fan-out. It runs one child contract per item hash and returns a `CollectionResult` keyed by stable item identity.
+store = Igniter::Runtime::Stores::MemoryStore.new
 
-In `mode: :collect`, a collection can succeed overall while still containing failed items. In that case:
+# Launch — suspends waiting for both events
+execution = LeadWorkflow.start({ request_id: "r1" }, store: store)
+execution.pending?  # => true
 
-- `result.summary` gives collection-level status such as `:partial_failure`
-- `result.items_summary` gives compact per-item status
-- `result.failed_items` gives only failed item details
-- `contract.diagnostics_text` and `contract.diagnostics_markdown` include collection failure summaries
+# Deliver events from any process or webhook handler
+LeadWorkflow.deliver_event(:crm_received,
+  correlation: { request_id: "r1" },
+  payload: { company: "Acme Corp", tier: "enterprise" },
+  store: store)
 
-See `examples/collection_partial_failure.rb` for a runnable example.
+LeadWorkflow.deliver_event(:billing_received,
+  correlation: { request_id: "r1" },
+  payload: { mrr: 500 },
+  store: store)
+# => prints "Report ready: { crm: ..., billing: ... }"
+```
 
-## Composition Example
+See [`examples/distributed_server.rb`](examples/distributed_server.rb) and [`docs/DISTRIBUTED_CONTRACTS_V1.md`](docs/DISTRIBUTED_CONTRACTS_V1.md).
 
-```ruby
-class PricingContract < Igniter::Contract
-  define do
-    input :order_total, type: :numeric
+### 10. igniter-server
 
-    compute :gross_total, depends_on: [:order_total] do |order_total:|
-      order_total * 1.2
-    end
+Host contracts as an HTTP service and call them from another graph with the `remote:` DSL:
 
-    output :gross_total
+```ruby
+# --- Service node on port 4568 ---
+require "igniter/server"
+
+class ScoringContract < Igniter::Contract
+  define do
+    input :value
+    compute :score, depends_on: :value, call: ->(value:) { value * 1.5 }
+    output :score
   end
 end
 
-class CheckoutContract < Igniter::Contract
-  define do
-    input :order_total, type: :numeric
+Igniter::Server.configure { |c| c.port = 4568; c.register "ScoringContract", ScoringContract }
+Igniter::Server.start
 
-    compose :pricing, contract: PricingContract, inputs: {
-      order_total: :order_total
-    }
+# --- Orchestrator on port 4567 ---
+require "igniter/server"
 
-    output :pricing
+class PipelineContract < Igniter::Contract
+  define do
+    input :data
+    remote :scored,
+           contract: "ScoringContract",
+           node:     "http://localhost:4568",
+           inputs:   { value: :data }
+    output :scored
   end
 end
 
-CheckoutContract.new(order_total: 100).result.pricing.gross_total
-# => 120.0
+Igniter::Server.configure { |c| c.port = 4567; c.register "PipelineContract", PipelineContract }
+Igniter::Server.start
 ```
 
-## Reactive Example
+**CLI:**
+
+```bash
+igniter-server start --port 4568 --require ./contracts.rb
+```
+
+**Rack / Puma (`config.ru`):**
 
 ```ruby
-class NotifyingContract < Igniter::Contract
-  define do
-    input :order_total, type: :numeric
-    output :order_total
-  end
+require "igniter/server"
+require_relative "contracts"
+Igniter::Server.configure { |c| c.register "ScoringContract", ScoringContract }
+run Igniter::Server.rack_app
+```
+
+**REST API:**
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `POST` | `/v1/contracts/:name/execute` | Execute a contract synchronously |
+| `POST` | `/v1/contracts/:name/events` | Deliver an event to a distributed contract |
+| `GET`  | `/v1/executions/:id` | Poll execution status |
+| `GET`  | `/v1/health` | Health check with registered contracts list |
+| `GET`  | `/v1/contracts` | List contracts with inputs and outputs |
+
+See [`docs/SERVER_V1.md`](docs/SERVER_V1.md) for the full API reference, deployment patterns, and security notes.
+
+### 11. LLM Integration
+
+Use language models as first-class compute nodes. Supported providers: Ollama (local, zero API cost),
+Anthropic (Claude), OpenAI (and compatible APIs: Groq, Mistral, Azure OpenAI):
+
+```ruby
+require "igniter/integrations/llm"
+
+Igniter::LLM.configure do |c|
+  c.default_provider = :anthropic
+  c.anthropic.api_key = ENV["ANTHROPIC_API_KEY"]
+end
+
+class ClassifyExecutor < Igniter::LLM::Executor
+  provider :anthropic
+  model    "claude-haiku-4-5-20251001"
+  system_prompt "Classify feedback into: bug_report, feature_request, question."
 
-  on_success :order_total do |value:, **|
-    puts "Resolved #{value}"
+  def call(feedback:)
+    complete("Classify: #{feedback}")
   end
 end
-```
 
-Or attach directly to a node event when you want the node value:
+class DraftResponseExecutor < Igniter::LLM::Executor
+  provider :anthropic
+  model    "claude-haiku-4-5-20251001"
+  system_prompt "You are a customer success agent. Write one professional response sentence."
 
-```ruby
-class NotifyingContract < Igniter::Contract
-  define do
-    input :order_total, type: :numeric
-    output :order_total
+  def call(feedback:, category:)
+    complete("Feedback: #{feedback}\nCategory: #{category}\nDraft a response.")
   end
+end
+
+class FeedbackTriageContract < Igniter::Contract
+  define do
+    input :feedback
 
-  effect "order_total" do |event:, value:, **|
-    puts "Resolved #{event.path}"
+    compute :category, depends_on: :feedback,             with: ClassifyExecutor
+    compute :response, depends_on: %i[feedback category], with: DraftResponseExecutor
+
+    output :category
+    output :response
   end
 end
 ```
 
-## Introspection
+Multi-step reasoning with conversation history:
 
 ```ruby
-PriceContract.graph.to_text
-PriceContract.graph.to_mermaid
+class MultiStepExecutor < Igniter::LLM::Executor
+  def call(text:, prior_analysis:)
+    ctx = Context.empty(system: self.class.system_prompt)
+      .append_user("Initial: #{text}")
+      .append_assistant(prior_analysis)
+    chat(context: ctx)
+  end
+end
+```
 
-contract = PriceContract.new(order_total: 100, country: "UA")
-contract.result.gross_total
+See [`examples/llm/research_agent.rb`](examples/llm/research_agent.rb), [`examples/llm/tool_use.rb`](examples/llm/tool_use.rb), and [`docs/LLM_V1.md`](docs/LLM_V1.md).
 
-contract.result.states
-contract.result.explain(:gross_total)
-contract.explain_plan
-contract.execution.to_h
-contract.execution.as_json
-contract.result.as_json
-contract.events.map(&:as_json)
-contract.diagnostics.to_h
-contract.diagnostics_text
-contract.diagnostics_markdown
-contract.audit_snapshot
-```
+## Examples
 
-## v2 Design Docs
+| Example | Run | Shows |
+|---------|-----|-------|
+| `basic_pricing.rb` | `ruby examples/basic_pricing.rb` | Basic contract, lazy resolution, input updates |
+| `composition.rb` | `ruby examples/composition.rb` | Nested contracts and composed results |
+| `diagnostics.rb` | `ruby examples/diagnostics.rb` | Diagnostics text and machine-readable output |
+| `async_store.rb` | `ruby examples/async_store.rb` | Pending execution, file-backed store, worker-style resume |
+| `marketing_ergonomics.rb` | `ruby examples/marketing_ergonomics.rb` | `const`, `lookup`, `map`, `guard`, `scope`, `namespace`, `expose`, `on_success`, `explain_plan` |
+| `collection.rb` | `ruby examples/collection.rb` | Fan-out, stable item keys, `CollectionResult` |
+| `collection_partial_failure.rb` | `ruby examples/collection_partial_failure.rb` | `:collect` mode, partial failure summary, collection diagnostics |
+| `ringcentral_routing.rb` | `ruby examples/ringcentral_routing.rb` | `branch`, nested `collection`, `project`, `aggregate`, diagnostics |
+| `order_pipeline.rb` | `ruby examples/order_pipeline.rb` | `guard` + `collection` + `branch` + `export` in one flow |
+| `distributed_server.rb` | `ruby examples/distributed_server.rb` | `await`, `correlate_by`, `start`, `deliver_event`, `on_success` |
+| `server/node1.rb` + `node2.rb` | run both, then curl | Two-node igniter-server with `remote:` DSL |
+| `llm/research_agent.rb` | `ruby examples/llm/research_agent.rb` | Multi-step LLM pipeline with Ollama |
+| `llm/tool_use.rb` | `ruby examples/llm/tool_use.rb` | LLM tool declarations, chained LLM nodes, `Context` |
+
+## Design Docs
 
 - [Architecture v2](docs/ARCHITECTURE_V2.md)
 - [Execution Model v2](docs/EXECUTION_MODEL_V2.md)
@@ -445,42 +474,33 @@ contract.audit_snapshot
 - [Patterns](docs/PATTERNS.md)
 - [Branches v1](docs/BRANCHES_V1.md)
 - [Collections v1](docs/COLLECTIONS_V1.md)
+- [Distributed Contracts v1](docs/DISTRIBUTED_CONTRACTS_V1.md)
 - [Store Adapters](docs/STORE_ADAPTERS.md)
+- [igniter-server v1](docs/SERVER_V1.md)
+- [LLM Integration v1](docs/LLM_V1.md)
 - [Concepts and Principles](docs/IGNITER_CONCEPTS.md)
 
-## Direction
-
-The v2 rewrite is based on these rules:
-
-- model, compiler, runtime, DSL, and extensions are separate layers
-- graph validation happens before runtime
-- auditing and reactive behavior are extensions over events, not runtime internals
-- the first target is a deterministic synchronous kernel
-
-## Status
-
-The public Ruby surface in `lib/` now contains only the v2 core exposed from `require "igniter"`.
-
 ## Development
 
 ```bash
-rake spec
+rake          # specs + RuboCop
+rake spec     # tests only
+rake rubocop  # lint only
+rake build    # build gem
 ```
 
-Current baseline:
-
-- synchronous runtime
-- parallel thread-pool runner
-- pending/deferred runtime states
-- snapshot/restore execution lifecycle
-- store-backed resume flow
-- compile-time graph validation
-- typed inputs
-- composition
-- auditing
-- diagnostics reporting
-- reactive subscriptions
-- graph/runtime introspection
+Current feature baseline:
+
+- synchronous runtime + parallel thread-pool runner
+- pending / deferred node states with snapshot / restore
+- store-backed resume flow (MemoryStore, FileStore)
+- compile-time graph validation, typed inputs, cycle detection
+- composition, branch, collection, guard, scope / namespace
+- distributed workflows: `await`, `correlate_by`, `start`, `deliver_event`
+- igniter-server: TCP server, Rack adapter, CLI, `remote:` DSL
+- LLM compute nodes: Ollama, Anthropic, OpenAI providers
+- Rails integration: Railtie, ActiveJob, ActionCable, webhook controller mixin
+- auditing, diagnostics, reactive subscriptions, graph introspection
 
 ## License