phronomy 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e4dd11eb68b4f8d9f1eb9b75630a21424ee2d5c32035e2be9f9d8c34318feee
-  data.tar.gz: ba85c6000643e00d6bc20298385728cc67df70b17f3542b439f516b4a23e92e5
+  metadata.gz: a5d8907f1d87037c09f78f63dd8ddbd21605536b1aa53c2d43e52be4a6ab6791
+  data.tar.gz: 37260258f4ece53e6e5b748cb2236f9c99f6f7e5c754fb0c2d72c415b0137386
 SHA512:
-  metadata.gz: 1086a00d3ee1957b00954ac0a1ea70464c7e873e0cb873e23e53f27a38972d9a2bacca90204742c4c2c6cff90a3fa7972984ef2f16431187d5aa050ba4989ac3
-  data.tar.gz: 8728503fb317f3ce9f05624d648e8080001cac7096898bd5ff2c95c736a040159a42d7ce26eebb28451afd367331d7a50fbe26ce37bf879d20a2de337247a76d
+  metadata.gz: 1533e2e0d82283066bab5f80b6583497330b274396640b91a6b27b1706533e4d25842600eb023c0fd469c8da076101f43e5691218703faedce194cd74476c590
+  data.tar.gz: af0513115bfcd23f786dfbedb7bfa7947346bb36168cc62175bd900f8536d984789469afc1fd929de90fca9a6b8cd8496451a054ea3ca86af401ef142b1c3e95

data/CHANGELOG.md

@@ -7,6 +7,131 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [0.4.0] - 2026-05-19
+
+### Removed
+
+- **`Phronomy::TrustPipeline` removed**: The `TrustPipeline` class and its inner
+  `TrustResult` value object have been deleted. Use `Phronomy::GeneratorVerifier`
+  instead, which provides the same generator-verifier pattern with a cleaner,
+  fully injectable API.
+
+### Added
+
+- **`Phronomy::GeneratorVerifier`** — Generator-Verifier coordination loop
+  (Anthropic blog, Pattern 1). Wraps a generator agent and a verifier agent with
+  fully injectable prompt builders, response parsers, a configurable iteration
+  limit, and an approval-outcome raise policy.
+- **`Phronomy::Agent::Orchestrator`** — Base class for orchestrator agents
+  (Anthropic blog, Pattern 2). Extends `Agent::Base` with a `subagent` DSL for
+  declarative subagent registration as LLM-callable tools, plus `dispatch_parallel`
+  and `fan_out` for programmatic parallel invocation.
+- **`Phronomy::Agent::TeamCoordinator`** — Agent teams coordination pattern
+  (Anthropic blog, Pattern 3). An LLM-powered coordinator with a shared task
+  queue and a pool of worker agents that carry conversation history across task
+  assignments. Adds `coordinator_provider` DSL for independent LLM routing.
+- **`Phronomy::Agent::SharedState`** — Shared-state coordination pattern
+  (Anthropic blog, Pattern 5). Peer agents collaborate via a `KnowledgeStore`;
+  the `member` DSL registers agents with per-agent instructions; `coordination`
+  sets the team protocol; `build_prompt` injects a tool-usage guide automatically.
+- **`Phronomy::LowConfidenceError`** — Exception raised by `GeneratorVerifier`
+  when `raise_policy: :raise` and verification fails after exhausting the
+  iteration limit.
+
+### Changed
+
+- **`Phronomy::Graph::StateGraph` event system refactored**: Per-node `advance`
+  events replaced with a unified `node_completed` event queue, reducing
+  event-handler registration overhead and simplifying listener registration.
+
+---
+
+## [0.3.0] - 2026-05-18
+
+### Removed
+
+- **`Phronomy::Memory` module fully removed**: `ConversationManager`, all
+  `Storage` backends (InMemory, ActiveRecord), all `Retrieval` strategies
+  (Recent, Semantic, Composite), and all `Compression` helpers (ToolOutputPruner,
+  Summary) have been deleted. Conversation history is now the responsibility of
+  the calling application — pass prior messages via `config[:messages]`
+  (`Array<RubyLLM::Message>`) and receive the updated array in `result[:messages]`.
+- **`Phronomy::StateStore` module fully removed**: `InMemory`, `ActiveRecord`,
+  `Redis`, and `FileSystem` state-store backends have been deleted. The Workflow
+  halted-state object is now returned directly from `invoke` and `send_event`
+  and must be stored by the caller if resumption is needed.
+- **`Phronomy::Configuration#default_state_store` removed**: No longer meaningful
+  without a built-in state store.
+- **`Phronomy::Configuration#default_memory` / `#memory_async` / `#memory_job_queue` removed**:
+  No longer meaningful without the Memory module.
+- **Rails integration removed**: `Railtie` initializers for `AgentJob` and
+  `acts_as_phronomy_message` no longer load. The `rails/` and `active_record/`
+  directories have been deleted.
+- **`Phronomy::Actor` and `Phronomy::ThreadActorRegistry` deleted**: The Active
+  Object pattern implementation (`actor.rb`, `thread_actor_registry.rb`) has been
+  removed. It provided synchronous blocking only (no true async) and was
+  architecturally inconsistent with the `WorkflowRunner` halt/resume model. All
+  thread coordination now uses plain `Mutex` where needed.
+- **`Phronomy.configuration.max_actors` removed**: The configuration option is no
+  longer meaningful without `ThreadActorRegistry`.
+
+### Changed
+
+- **`Agent::Base#invoke` and `#stream`** no longer route execution through a
+  per-thread Actor. Both methods now call `_invoke_impl` / `_stream_impl` directly
+  on the calling thread.
+- **`Memory::Storage::InMemory`** now stores all thread data in an instance-level
+  `Hash` instead of `Thread.current` thread-local storage. The class-level
+  `THREAD_DATA_KEY` constant has been removed. `with_thread_lock` uses a
+  per-thread-id `Mutex` to preserve concurrent-compaction safety (issue #44).
+- **`StateStore::InMemory`** now stores state in an instance-level `Hash`.
+  The `THREAD_DATA_KEY` constant has been removed.
+- **`VectorStore::RedisSearch`** uses a `Mutex` for `ensure_index!` and `clear`
+  instead of an Actor, preserving the thread-safety invariant on `@index_created`.
+- **`Tool::McpTool::StdioTransport`**, **`Tracing::LangfuseTracer`**,
+  **`TrustPipeline`**, and **`Memory::Retrieval::Semantic`** no longer hold a
+  dedicated Actor instance. All operations execute directly on the calling thread.
+- **`PIIPatternDetector` — `:my_number` replaced by `:ssn`** ([#77]): The built-in PII
+  detector now checks for US Social Security Numbers (`\b\d{3}-\d{2}-\d{4}\b`) instead
+  of Japanese My Numbers. The JIS X 0076 check-digit validation and `my_number_valid?`
+  helper have been removed. Category key renamed from `:my_number` to `:ssn`.
+- **`PIIPatternDetector` — phone pattern updated to international format** ([#77]):
+  The `:phone` pattern now matches 3-digit area code + 3–4-digit exchange + 4-digit
+  subscriber number with optional E.164 country-code prefix
+  (`(?:\+\d{1,3}[.\- ]?)?\(?\d{3}\)?[.\- ]?\d{3,4}[.\- ]?\d{4}\b`),
+  replacing the previous Japan-specific pattern.
+
+### Fixed
+
+- **`RubyLLM::Providers::OpenAI#handle_error_chunk` — `NoMethodError` on single-line SSE error chunks**:
+  Some models (e.g. Qwen running via LM Studio) return SSE error events as a
+  single line (`data: {...}`) without a preceding `event:` line. The upstream
+  implementation called `chunk.split("\n")[1].delete_prefix(...)`, which raised
+  `NoMethodError: undefined method 'delete_prefix' for nil` when the second
+  element was absent. A monkey-patch in `lib/phronomy/ruby_llm_patches.rb` guards
+  against this by returning an empty string when the split result has fewer than
+  two elements.
+- **`README` — stale Memory API examples** ([#76]): All references to the
+  non-existent `WindowMemory`, `ActiveRecordMemory`, `SemanticMemory` classes and
+  `load_messages` / `memory_compression` API have been replaced with the correct
+  `ConversationManager`-based API.
+- **`README` — `PIIPatternDetector` comment** ([#77]): Inline comment updated to
+  `# Detect SSNs, credit cards, emails, and phone numbers`.
+- **`README` — Configuration block markdown** ([#80]): The `max_actors` Note block
+  was incorrectly placed inside the Ruby code fence; moved outside so it renders
+  as a blockquote.
+- **`README` — `Guardrails` stability label** ([#76]): Changed from `Stable` to `Beta`
+  to reflect that the built-in detector patterns may evolve.
+- **`CHANGELOG` — stale entries** ([#78]): Removed the orphaned `[Unreleased]` section
+  describing a never-released API, and replaced a forward `"As of 0.3.0"` reference
+  with future-tense wording.
+- **`McpTool` — YARD class comment** ([#79]): Updated to document both the
+  `stdio://` and `http://`/`https://` transport schemes.
+- **`README` — `max_actors` configuration reference** ([#80]): Added `c.max_actors`
+  example and LRU eviction note to the Configuration section.
+
+---
+
 ## [0.2.2] - 2026-05-17
 
 ### Fixed
@@ -61,8 +186,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`WorkflowRunner` — state_machines fully drives execution** (architecture overhaul).
   Previously `state_machines` was used only for post-hoc transition validation;
   the next-node was calculated by Phronomy internally (`resolve_next_node`).
-  As of 0.3.0, all state transition decisions — including guard evaluation for
-  routing events — are delegated entirely to `state_machines`.
+  After this change, all state transition decisions — including guard evaluation for
+  routing events — will be delegated entirely to `state_machines`.
   - `PhaseTracker` now exposes `attr_accessor :context` so guard lambdas can
     access the `WorkflowContext` via `m.context`.
   - Guard bridge pattern: `if: ->(m) { guard_proc.call(m.context) }`.
@@ -87,34 +212,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
-## [Unreleased]
-
-### Added
-
-- **`Phronomy::Graph::Context`** module — canonical module for defining workflow
-  context classes (replaces the removed `Phronomy::Graph::State`).
-- **`Phronomy::Graph.register_context_class`** — registers context classes for
-  deserialization from external stores (Redis, DB).
-- **`Phronomy::Workflow.define`** DSL — primary high-level API for declaring
-  stateful workflows (`state`, `wait_state`, `event`, `after`, `initial`).
-- **`Phronomy::Graph::WorkflowRunner`** — state-machine execution engine backing
-  the Workflow DSL. Replaces the removed `CompiledGraph`.
-- **`app.send_event(event, config:)`** — event-driven resume for workflows halted
-  at a `wait_state`.
-- **`state.halted?`** — returns `true` when the workflow is paused at a `wait_state`.
-- **`state.phase`** — single source of truth for execution state.
-
-### Removed
-
-- `Phronomy::Graph::StateGraph` / `CompiledGraph` — use `Phronomy::Workflow.define`.
-- `Phronomy::Graph::State` — use `Phronomy::Graph::Context`.
-- `Phronomy::Graph.register_state_class` — use `register_context_class`.
-- `state.current_nodes` / `state.halted_before` — use `state.phase` / `state.halted?`.
-- `compiled.interrupt_before` / `compiled.interrupt_after` — use `wait_state` + `event`.
-- `compiled.resume` — use `app.send_event`.
-
----
-
 ## [0.2.0] - 2026-05-13
 
 ### Added

data/README.md

@@ -1,7 +1,7 @@
 # Phronomy
 
 **Phronomy** is a Ruby AI agent framework inspired by open-source AI agent frameworks.  
-It provides composable building blocks — Workflows, Agents, and Memory — all powered by [RubyLLM](https://github.com/crmne/ruby_llm) for LLM abstraction.
+It provides composable building blocks — Workflows, Agents, Tools, Guardrails, RAG, and Tracing — all powered by [RubyLLM](https://github.com/crmne/ruby_llm) for LLM abstraction.
 
 ## Features
 
@@ -13,21 +13,20 @@ It provides composable building blocks — Workflows, Agents, and Memory — all
 |---|---|
 | **Workflow** — Stateful, branching workflows with wait_state/send_event | Stable |
 | **Workflow Parallel Node** — Concurrent branches via application-level threads | Beta |
-| **Agent** — ReAct-style tool-calling agents with memory and guardrails | Stable |
+| **Agent** — ReAct-style tool-calling agents with guardrails and conversation history | Stable |
 | **Before-Completion Hook** — Three-tier LLM parameter injection | Stable |
-| **Memory** — Window, summary, ActiveRecord-backed, semantic, and composite memory | Stable |
-| **Memory Compression** — Automatic summarisation and tool-output pruning | Beta |
 | **Context Management** — Token budget calculation, estimation, and pruning | Stable |
 | **Knowledge/RAG** — Retrieval sources with pluggable loaders, splitters, and vector stores | Beta |
 | **Multi-agent** — Agent-as-Tool pattern and hub-and-spoke handoff routing | Beta |
-| **TrustPipeline** — Self-review loop and confidence gate (citations are LLM-self-reported) | Experimental |
-| **Guardrails** — Input/output validation; built-in PII and prompt-injection detectors | Stable |
+| **GeneratorVerifier** — Generator-Verifier loop with injectable prompt builders/parsers | Beta |
+| **Agent::Orchestrator** — Parallel subagent dispatch, fan-out, and `subagent` DSL | Beta |
+| **Agent::TeamCoordinator** — Agent teams pattern: LLM coordinator + persistent worker pool with task queue | Beta |
+| **Agent::SharedState** — Shared state pattern: peer agents collaborate via a shared KnowledgeStore; `member` DSL with per-agent instructions and `coordination` team protocol | Experimental |
+| **Guardrails** — Input/output validation; built-in PII and prompt-injection detectors | Beta |
 | **Output Parser** — JSON and Struct-mapped parsers for structured LLM responses | Stable |
 | **Eval Framework** — Dataset-driven evaluation with multiple scorer types | Beta |
 | **Tracing** — Pluggable span-based observability | Stable |
-| **StateStore** — Persist graph state to memory, ActiveRecord, Redis, or file system | Stable |
 | **MCP Tool** — Model Context Protocol server integration | Beta |
-| **Rails integration** — `AgentJob`, `acts_as_phronomy_message`, and generators | Beta |
 
 ## Installation
 
@@ -49,7 +48,7 @@ For Rails apps, run the install generator after bundling:
 rails generate phronomy:install
 ```
 
-This creates an initializer and the required database migrations.
+This creates a configuration initializer.
 
 ## Quick Start
 
@@ -99,8 +98,6 @@ app = Phronomy::Workflow.define(ReviewContext) do
   event :reject,  from: :awaiting_approval, to: :write
 end
 
-Phronomy.configure { |c| c.default_state_store = Phronomy::StateStore::InMemory.new }
-
 # First run — halts at :awaiting_approval
 state = app.invoke({ draft: "" }, config: { thread_id: "doc-1" })
 puts "Halted: #{state.halted?}"   # => true
@@ -160,7 +157,7 @@ agent.add_input_guardrail(NoSensitiveDataGuardrail.new)
 ### Built-in Guardrails — PII and prompt injection detection
 
 ```ruby
-# Detect credit cards, SSNs, emails, and phone numbers automatically
+# Detect SSNs, credit cards, emails, and phone numbers
 agent.add_input_guardrail(Phronomy::Guardrail::Builtin::PIIPatternDetector.new)
 
 # Block common prompt-injection attempts
@@ -232,23 +229,88 @@ end
 
 Hooks are called in order — global → class → instance — and deep-merged.
 
-### TrustPipeline — Trustworthy outputs with citations and review
+### GeneratorVerifier — Generator-Verifier loop with custom prompt builders
 
 ```ruby
-pipeline = Phronomy::TrustPipeline.new(
-  draft_agent:          PolicyDraftAgent,
-  review_agent:         PolicyReviewAgent,
+pipeline = Phronomy::GeneratorVerifier.new(
+  draft_agent:  PolicyDraftAgent,
+  review_agent: PolicyReviewAgent,
+
+  # Full control over the LLM dialogue — supply your own prompts.
+  draft_prompt_builder: ->(input, feedback) {
+    base = "Answer precisely: #{input}"
+    feedback ? "#{base}\n\nPrevious feedback: #{feedback}" : base
+  },
+  review_prompt_builder: ->(input, draft, citations) {
+    "Is this draft accurate? Draft: #{draft}"
+  },
+
   confidence_threshold: 0.7,
-  max_iterations:       3
+  max_iterations:       3,
+  raise_if_untrusted:   false   # set true to raise LowConfidenceError
 )
 
 result = pipeline.invoke("What is the refund policy?")
-puts result.output             # final answer
-puts result.trusted?           # true when confidence >= 0.7
-puts result.confidence         # Float 0.0–1.0
+puts result.output      # final answer
+puts result.trusted?    # true when confidence >= 0.7
+puts result.confidence  # Float 0.0–1.0
+result.citations.each { |c| puts "#{c[:source]}: #{c[:excerpt]}" }
+```
+
+Optionally inject a custom result parser to decode non-JSON LLM output:
+
+```ruby
+pipeline = Phronomy::GeneratorVerifier.new(
+  # ... (required params as shown above)
+  draft_result_parser:  ->(text) { my_custom_draft_parser(text) },
+  review_result_parser: ->(text) { my_custom_review_parser(text) }
+)
+```
+
+Raise on low confidence:
+
+```ruby
+begin
+  result = pipeline.invoke("question")
+rescue Phronomy::LowConfidenceError => e
+  puts "Untrusted (confidence #{e.result.confidence}): #{e.result.output}"
+end
+```
+
+### Agent::Orchestrator — Parallel subagent dispatch
+
+```ruby
+class ResearchOrchestrator < Phronomy::Agent::Orchestrator
+  model "gpt-4o"
+  instructions "Coordinate research tasks by dispatching to specialised agents."
+
+  # Each subagent is automatically exposed as an LLM-callable tool.
+  subagent :searcher,   SearchAgent
+  subagent :summarizer, SummaryAgent, on_error: :skip
+end
+
+result = ResearchOrchestrator.new.invoke("Research the latest AI news.")
+```
+
+Programmatic parallel dispatch (no LLM loop):
+
+```ruby
+class MyOrchestrator < Phronomy::Agent::Orchestrator
+  model "gpt-4o"
+  instructions "Orchestrate."
+
+  def run(query)
+    # Heterogeneous agents in parallel
+    results = dispatch_parallel(
+      {agent: SearchAgent,   input: "topic A"},
+      {agent: AnalysisAgent, input: query}
+    )
+
+    # Fan-out — same agent, multiple inputs
+    translations = fan_out(agent: TranslationAgent, inputs: %w[Hello World])
 
-result.citations.each do |c|
-  puts "#{c[:source]}: #{c[:excerpt]}"
+    results.map { |r| r[:output] }.join("\n")
+  end
 end
 ```
 
@@ -332,35 +394,28 @@ search_tool = Phronomy::Tool::McpTool.from_server(
 )
 ```
 
-### Rails — ActiveRecord persistence
+### Conversation History — passing prior messages
 
-```ruby
-# In your migration (generated by rails generate phronomy:install):
-# create_table :phronomy_messages ...
-# create_table :phronomy_states ...
+Phronomy does not manage conversation history internally. Instead, the application owns the
+message array and passes it in via `config[:messages]`:
 
-class PhronomyMessage < ApplicationRecord
-  acts_as_phronomy_message
-end
-
-# config/initializers/phronomy.rb
-Phronomy.configure do |c|
-  c.default_state_store = Phronomy::StateStore::ActiveRecord.new(
-    model_class: PhronomyState  # AR model backed by phronomy_states table
-  )
-end
-
-# Use in a controller:
-agent = ResearchAgent.new
-result = agent.invoke(
-  params[:message],
-  config: {
-    thread_id: "user_#{current_user.id}",
-    memory:    PhronomyMessage.phronomy_memory
-  }
+```ruby
+# First turn
+result1 = MyAgent.new.invoke("Hello! I'm Alice.", config: { thread_id: "session-1" })
+prior_messages = result1[:messages]   # Array<RubyLLM::Message>
+
+# Second turn — pass prior messages so the agent has context
+result2 = MyAgent.new.invoke(
+  "What is my name?",
+  config: { messages: prior_messages, thread_id: "session-1" }
 )
+puts result2[:output]   # => "Your name is Alice."
 ```
 
+`result[:messages]` contains the complete message history after each invocation.
+Persist it however suits your application (in-memory hash, Redis, ActiveRecord, etc.).
+
+
 ## Configuration
 
 ```ruby
@@ -368,9 +423,7 @@ Phronomy.configure do |c|
   c.default_model       = "gpt-4o-mini"
   c.recursion_limit     = 25
   c.tracer              = Phronomy::Tracing::NullTracer.new
-  c.default_state_store = Phronomy::StateStore::InMemory.new  # optional
-  c.memory_compression  = []                                   # optional; Array of compressors
-  c.before_completion   = nil                                  # optional; global hook lambda
+  c.before_completion   = nil   # optional; global hook lambda
 end
 ```
 
@@ -402,24 +455,6 @@ budget = Phronomy::Context::TokenBudget.new(
 )
 ```
 
-### Budget-aware Memory
-
-Pass a budget to `load_messages` and only the newest messages that fit are returned:
-
-```ruby
-memory = Phronomy::Memory::WindowMemory.new
-messages = memory.load_messages(thread_id: "t1", token_budget: budget)
-```
-
-`ActiveRecordMemory` also accepts `pruner:` to truncate oversized tool results:
-
-```ruby
-memory = Phronomy::Memory::ActiveRecordMemory.new(
-  model_class: PhronomyMessage,
-  pruner: Phronomy::Memory::Compression::ToolOutputPruner.new(max_chars: 4000)
-)
-```
-
 ### Agent DSL extensions
 
 ```ruby
@@ -430,59 +465,8 @@ class MyAgent < Phronomy::Agent::Base
 end
 ```
 
-`Agent::Base#invoke` builds a `TokenBudget` automatically and passes it to
-`memory.load_messages`.  When the model is not in the registry the budget is
-silently skipped.
-
-### SemanticMemory
-
-Embedding-based retrieval of relevant past messages:
-
-```ruby
-semantic = Phronomy::Memory::SemanticMemory.new(
-  embedding_model: "text-embedding-3-small",
-  k: 10
-)
-messages = semantic.load_messages(thread_id: "t1", query: "user's current question")
-```
-
-### Composite retrieval
-
-Merge multiple retrieval strategies within a shared `ConversationManager`:
-
-```ruby
-composite_retrieval = Phronomy::Memory::Retrieval::Composite.new(
-  sources: [
-    { retrieval: Phronomy::Memory::Retrieval::Recent.new(k: 5),    weight: 0.4 },
-    { retrieval: Phronomy::Memory::Retrieval::Semantic.new(k: 10), weight: 0.6 }
-  ]
-)
-
-manager = Phronomy::Memory::ConversationManager.new(
-  storage:   Phronomy::Memory::Storage::InMemory.new,
-  retrieval: composite_retrieval
-)
-```
-
-### Memory Compression
-
-Automatically shrink conversation history before it reaches the LLM.
-
-```ruby
-# Truncate oversized tool outputs (no LLM call, cheap)
-pruner = Phronomy::Memory::Compression::ToolOutputPruner.new(max_chars: 4000)
-
-# Summarise old messages when history exceeds max_tokens (calls summarizer_model)
-summary = Phronomy::Memory::Compression::Summary.new(
-  max_tokens:       4000,
-  keep:             10,             # always preserve the N most recent messages
-  summarizer_model: "gpt-4o-mini"
-)
-
-Phronomy.configure do |c|
-  c.memory_compression = [pruner, summary]   # applied in order: pruner first, then summary
-end
-```
+`Agent::Base#invoke` builds a `TokenBudget` automatically. When the model is not in the
+registry the budget is silently skipped.
 
 
 ## Examples
@@ -512,11 +496,11 @@ bundle exec ruby NN_example_name/run.rb
 | 12 | `12_prompt_template/` | Advanced prompt templates |
 | 13 | `13_mcp_http_tool/` | HTTP-based MCP tool server |
 | 14 | `14_code_review/` | Automated code review agent |
-| 15 | `15_rails_secure_chat/` | Rails chat with PII guardrails and secure memory |
+| 15 | `15_rails_secure_chat/` | Rails chat with PII guardrails |
 | 16 | `16_before_completion_hook/` | Global/class/instance before_completion hooks |
 | 17 | `17_multi_agent_handoff/` | Hub-and-spoke agent routing via Runner |
 | 18 | `18_rails_agent_job/` | Rails app with AgentJob + ActionCable streaming |
-| 19 | `19_trust_pipeline/` | Trustworthy output via Citation Tracking + Self-Review + Confidence Gate |
+| 19 | `19_trust_pipeline/` | Generator-Verifier pattern with citation tracking, self-review loop and confidence gate |
 
 ## Development