agentic-codebase-navigator 1.2.0__tar.gz → 1.3.1__tar.gz

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/CHANGELOG.md

@@ -2,6 +2,93 @@
 
 This project follows a lightweight changelog format. The public API lives under the `rlm` import package.
 
+## 1.3.1
+
+Security patch release.
+
+### Security
+
+- **protobuf**: Bump `protobuf` from 6.33.2 to 6.33.5 to address CVE JSON recursion depth bypass in `ParseDict()` (CVSS 8.2, Dependabot alert #6)
+
+### Infrastructure
+
+- **CI**: Disable uv dependency cache in publish-only release jobs (`testpypi`, `pypi`) that lack checkout steps
+
+## 1.3.0
+
+Feature release introducing the **Relay Pipeline Library** — a type-safe, composable pipeline framework for orchestrating multi-step LLM workflows with conditional routing, parallel execution, and nested agent composition.
+
+### Features
+
+- **Relay Pipeline Library**: Full pipeline DSL for composing stateful LLM workflows (`src/rlm/domain/relay/`, `src/rlm/adapters/relay/`)
+  - `StateSpec[InputT, OutputT]` descriptors with operator overloading: `>>` (sequence), `|` (parallel), `.when()` (conditional)
+  - `Pipeline` builder for defining state graphs with typed edges, guards, and join groups
+  - `Baton[T]` immutable request-response envelope with validation, trace events, and metadata propagation
+  - Compile-time validation: type compatibility, reachability, terminal states, cycle detection via `validate_pipeline()`
+  - `allow_cycles(max_iterations=...)` decorator for intentional loops
+  - Full documentation in `docs/relay/`
+
+- **Pipeline Executors**: Sync and async orchestrators for pipeline execution
+  - `SyncPipelineExecutor` with `ThreadPoolExecutor` for parallel state execution
+  - `AsyncPipelineExecutor` with native `asyncio` concurrency
+  - Join aggregation: `"all"` (keyed dict) and `"race"` (first result) modes
+  - Guard evaluation, budget checks, and trace recording at each step
+
+- **State Executor Types**: Pluggable execution strategies for pipeline states
+  - `FunctionStateExecutor` — pure Python callables with optional retry
+  - `LLMStateExecutor` — LLM calls via `LLMPort` with request builder
+  - `AsyncStateExecutor` — async callables with event loop detection
+  - `RLMStateExecutor` — full agent orchestration as a pipeline state
+  - `SyncPipelineStateExecutor` / `AsyncPipelineStateExecutor` — nested pipeline composition
+
+- **Token Budget & Trace Tracking**: Execution observability across pipeline runs
+  - `TokenBudget` with max tokens, per-state estimates, and consumption tracking
+  - `PipelineTrace` immutable append-only audit log with state-level timing and status
+
+- **Pipeline Registry & LLM-Assisted Composition**: Dynamic pipeline discovery and chaining
+  - `PipelineTemplate` with name, description, types, factory, and tags
+  - `InMemoryPipelineRegistry` with substring and tag-based search
+  - `RootAgentComposer` — uses LLM to select and chain pipelines from registry
+
+- **Nested Agent Policy for Relay**: Agent-as-state integration
+  - `RelayNestedCallHandler` implements `NestedCallHandlerPort` + `NestedCallPolicy`
+  - Registry lookup, pipeline composition, synchronous execution with depth enforcement
+
+- **LLM Provider Resilience**: Exponential backoff retry across providers
+  - `RetryStrategy` with configurable max attempts, backoff, and exception types
+  - Applied to OpenAI, Azure OpenAI, LiteLLM, and Portkey adapters
+  - Enhanced debug logging and error handling across all providers
+
+- **Examples**: Three runnable examples demonstrating pipeline patterns
+  - `relay_conditional_routing.py` — if/else branching with guards
+  - `relay_parallel_join.py` — fan-out/fan-in with "all" join mode
+  - `relay_research_pipeline.py` — sequential multi-step chain with Pydantic models
+
+### Improvements
+
+- **Remote Environment Adapter**: New adapter with memory profiling support
+- **Enhanced Live LLM Testing**: `tests/live_llm.py` harness for opt-in provider smoke tests
+- **Tooling Optimization**: Improved mise venv and Python configuration
+- **Performance Thresholds**: Updated serialization benchmarks
+
+### Infrastructure
+
+- **New documentation files**:
+  - `docs/relay/overview.md` — Relay pipeline philosophy and quick start
+  - `docs/relay/composition.md` — DSL operators and composition patterns
+  - `docs/relay/states.md` — All executor types with usage examples
+  - `docs/relay/validation.md` — Pipeline validation rules and cycle handling
+- **SOPS Encrypted Secrets**: `.sops.yaml` + `.env.enc` for secure secrets management
+- **CI/CD Updates**: Bumped `actions/checkout` to v6, `actions/download-artifact` to v7, `astral-sh/setup-uv` to v7
+- **Dependency Updates**: `python-multipart` 0.0.21 → 0.0.22
+
+### Test Coverage
+
+- **11 new test files** spanning unit, integration, and e2e layers (~1,500 LOC)
+- Unit: baton, budget/trace, composition, executors, pipeline, state, validation
+- Integration: pipeline execution, composition chains, nested handler, nested policy (live)
+- E2E: full pipeline workflows, composition flows, nested policy integration
+
 ## 1.2.0-rc.1
 
 Major architecture release introducing declarative state machine orchestration, subprocess-based local execution, and optional Pydantic integration.

{agentic_codebase_navigator-1.2.0/src/agentic_codebase_navigator.egg-info → agentic_codebase_navigator-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-codebase-navigator
-Version: 1.2.0
+Version: 1.3.1
 Summary: Agentic codebase navigator built on Recursive Language Model (RLM) patterns.
 Author: Luiz Frias
 Maintainer: Luiz Frias
@@ -396,6 +396,36 @@ Available protocols:
 
 See [docs/extending.md](docs/extending.md) for detailed documentation.
 
+## Relay Pipeline Library
+
+Build type-safe, composable multi-step LLM workflows using a pipeline DSL:
+
+```python
+from rlm.domain.relay import StateSpec, Pipeline, Baton
+from rlm.adapters.relay.states import FunctionStateExecutor
+from rlm.adapters.relay.executors import SyncPipelineExecutor
+
+# Define states with typed inputs/outputs
+analyze = StateSpec[str, dict]("analyze", str, dict, FunctionStateExecutor(analyze_fn))
+summarize = StateSpec[dict, str]("summarize", dict, str, FunctionStateExecutor(summarize_fn))
+
+# Compose with operators: >> (sequence), | (parallel), .when() (conditional)
+pipeline = Pipeline(analyze >> summarize)
+
+# Execute with typed baton
+executor = SyncPipelineExecutor(pipeline)
+result = executor.run(Baton(payload="Analyze this codebase"))
+```
+
+**Key capabilities:**
+- **Conditional routing**: `state.when(predicate) >> target` with `.otherwise()` fallback
+- **Parallel execution**: `(left | right).join(mode="all")` with fan-out/fan-in
+- **Nested pipelines**: Use pipelines or full RLM agents as pipeline states
+- **Token budgets**: Track and enforce token consumption across pipeline runs
+- **Compile-time validation**: Type compatibility, reachability, and cycle detection
+
+See [docs/relay/overview.md](docs/relay/overview.md) for the full guide.
+
 ## LLM Provider Configuration
 
 | Provider | Extra | Environment Variables |
@@ -414,11 +444,14 @@ RLM uses a **hexagonal (ports & adapters) architecture**:
 ```
 src/rlm/
 ├── domain/          # Pure business logic, ports (protocols), models
+│   └── relay/       # Pipeline DSL: states, baton, validation, composition
 ├── application/     # Use cases, configuration
+│   └── relay/       # Pipeline registry composer
 ├── infrastructure/  # Wire protocol, execution policies
 ├── adapters/
 │   ├── llm/         # LLM providers (OpenAI, Anthropic, Gemini, etc.)
 │   ├── environments/# Execution environments (local, docker)
+│   ├── relay/       # Pipeline executors, state implementations
 │   ├── tools/       # Tool calling infrastructure
 │   ├── policies/    # Extension protocol implementations
 │   ├── broker/      # TCP broker for nested LLM calls
@@ -519,6 +552,14 @@ uv run --group dev ty check src/rlm
 - **Logger**: `JsonlLoggerAdapter`, `ConsoleLoggerAdapter`, `NoopLoggerAdapter`
 - **Tools**: `ToolRegistry`, `tool` decorator, `NativeToolAdapter`
 
+### Relay Pipeline
+
+- **`StateSpec`** - Type-safe state descriptor with operators (`>>`, `|`, `.when()`)
+- **`Pipeline`** - State graph builder with validation
+- **`Baton`** - Immutable request-response envelope
+- **`SyncPipelineExecutor`** / **`AsyncPipelineExecutor`** - Pipeline orchestrators
+- **State Executors**: `FunctionStateExecutor`, `LLMStateExecutor`, `RLMStateExecutor`, `AsyncStateExecutor`
+
 ### Extension Protocols
 
 - **`StoppingPolicy`** - Control iteration termination

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/README.md

@@ -327,6 +327,36 @@ Available protocols:
 
 See [docs/extending.md](docs/extending.md) for detailed documentation.
 
+## Relay Pipeline Library
+
+Build type-safe, composable multi-step LLM workflows using a pipeline DSL:
+
+```python
+from rlm.domain.relay import StateSpec, Pipeline, Baton
+from rlm.adapters.relay.states import FunctionStateExecutor
+from rlm.adapters.relay.executors import SyncPipelineExecutor
+
+# Define states with typed inputs/outputs
+analyze = StateSpec[str, dict]("analyze", str, dict, FunctionStateExecutor(analyze_fn))
+summarize = StateSpec[dict, str]("summarize", dict, str, FunctionStateExecutor(summarize_fn))
+
+# Compose with operators: >> (sequence), | (parallel), .when() (conditional)
+pipeline = Pipeline(analyze >> summarize)
+
+# Execute with typed baton
+executor = SyncPipelineExecutor(pipeline)
+result = executor.run(Baton(payload="Analyze this codebase"))
+```
+
+**Key capabilities:**
+- **Conditional routing**: `state.when(predicate) >> target` with `.otherwise()` fallback
+- **Parallel execution**: `(left | right).join(mode="all")` with fan-out/fan-in
+- **Nested pipelines**: Use pipelines or full RLM agents as pipeline states
+- **Token budgets**: Track and enforce token consumption across pipeline runs
+- **Compile-time validation**: Type compatibility, reachability, and cycle detection
+
+See [docs/relay/overview.md](docs/relay/overview.md) for the full guide.
+
 ## LLM Provider Configuration
 
 | Provider | Extra | Environment Variables |
@@ -345,11 +375,14 @@ RLM uses a **hexagonal (ports & adapters) architecture**:
 ```
 src/rlm/
 ├── domain/          # Pure business logic, ports (protocols), models
+│   └── relay/       # Pipeline DSL: states, baton, validation, composition
 ├── application/     # Use cases, configuration
+│   └── relay/       # Pipeline registry composer
 ├── infrastructure/  # Wire protocol, execution policies
 ├── adapters/
 │   ├── llm/         # LLM providers (OpenAI, Anthropic, Gemini, etc.)
 │   ├── environments/# Execution environments (local, docker)
+│   ├── relay/       # Pipeline executors, state implementations
 │   ├── tools/       # Tool calling infrastructure
 │   ├── policies/    # Extension protocol implementations
 │   ├── broker/      # TCP broker for nested LLM calls
@@ -450,6 +483,14 @@ uv run --group dev ty check src/rlm
 - **Logger**: `JsonlLoggerAdapter`, `ConsoleLoggerAdapter`, `NoopLoggerAdapter`
 - **Tools**: `ToolRegistry`, `tool` decorator, `NativeToolAdapter`
 
+### Relay Pipeline
+
+- **`StateSpec`** - Type-safe state descriptor with operators (`>>`, `|`, `.when()`)
+- **`Pipeline`** - State graph builder with validation
+- **`Baton`** - Immutable request-response envelope
+- **`SyncPipelineExecutor`** / **`AsyncPipelineExecutor`** - Pipeline orchestrators
+- **State Executors**: `FunctionStateExecutor`, `LLMStateExecutor`, `RLMStateExecutor`, `AsyncStateExecutor`
+
 ### Extension Protocols
 
 - **`StoppingPolicy`** - Control iteration termination

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/README.md

@@ -14,6 +14,7 @@ Welcome to the documentation for **agentic-codebase-navigator** (`rlm`) — an a
 | Add a new LLM provider | [LLM Providers](providers/llm-providers.md) |
 | Use different execution environments | [Environments](environments/execution-environments.md) |
 | Extend with custom policies | [Extension Protocols](extending/extension-protocols.md) |
+| Build multi-step LLM pipelines | [Relay Pipeline](relay/overview.md) |
 | Run tests | [Testing Guide](testing/testing-guide.md) |
 | Contribute to the project | [Contributing](contributing/development-setup.md) |
 | Release a new version | [Releasing](contributing/releasing.md) |
@@ -21,7 +22,7 @@ Welcome to the documentation for **agentic-codebase-navigator** (`rlm`) — an a
 
 ## Documentation Structure
 
-```
+```bash
 docs/
 ├── README.md                    # This file (navigation)
 ├── getting-started.md           # Quick start tutorial
@@ -40,6 +41,12 @@ docs/
 ├── extending/
 │   └── extension-protocols.md   # StoppingPolicy, ContextCompressor, NestedCallPolicy
 │
+├── relay/
+│   ├── overview.md              # Relay pipeline philosophy and quick start
+│   ├── composition.md           # DSL operators (>>, |, .when(), .join())
+│   ├── states.md                # State executor types and usage
+│   └── validation.md            # Pipeline validation and cycle detection
+│
 ├── testing/
 │   └── testing-guide.md         # How to run and write tests
 │
@@ -83,7 +90,7 @@ RLM supports two agent modes:
 
 RLM uses a **hexagonal (ports & adapters) architecture**:
 
-```
+```bash
 ┌─────────────────────────────────────────────────────────┐
 │                      API Layer                          │
 │              (RLM, create_rlm, factories)               │
@@ -104,7 +111,7 @@ RLM uses a **hexagonal (ports & adapters) architecture**:
 
 ## Version
 
-Current version: **1.1.0**
+Current version: **1.3.0**
 
 See [CHANGELOG.md](../CHANGELOG.md) for release history.
 

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/adr/0001-hexagonal-modular-monolith.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-Accepted (Phase 06)
+Accepted
 
 ## Context
 

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/adr/0002-optional-provider-dependencies.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-Accepted (Phase 06)
+Accepted
 
 ## Context
 

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/adr/0003-jsonl-log-schema-versioning.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-Accepted (Phase 06)
+Accepted
 
 ## Context
 

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/api-reference.md

@@ -1,4 +1,4 @@
-# Public API (Phase 06)
+# Public API
 
 This document defines the **stable user-facing Python API** for the refactored `rlm` package.
 
@@ -198,7 +198,68 @@ Tool calling is supported across multiple LLM providers:
 - **Gemini**: FunctionDeclaration format
 - **LiteLLM** / **Portkey**: Passthrough to underlying provider
 
-## Migration notes
+## Relay Pipeline Library
 
-The upstream snapshot remains available under `references/rlm/**` for reference only.
-Runtime code lives under `src/rlm/**`. Legacy has been fully removed.
+Type-safe, composable multi-step LLM workflows. See [Relay Overview](relay/overview.md) for the full guide.
+
+### Core Types
+
+```python
+from rlm.domain.relay import StateSpec, Pipeline, Baton, validate_pipeline, allow_cycles
+```
+
+| Type | Purpose |
+|------|---------|
+| `StateSpec[InputT, OutputT]` | Type-safe state descriptor with operator overloading |
+| `Pipeline` | State graph builder with edges, guards, and join groups |
+| `Baton[T]` | Immutable request-response envelope with metadata and trace |
+| `TokenBudget` | Token consumption tracking across pipeline runs |
+| `PipelineTrace` | Immutable append-only execution audit log |
+| `PipelineTemplate` | Registry entry with name, types, factory, and tags |
+| `InMemoryPipelineRegistry` | In-memory pipeline discovery with search |
+
+### Pipeline Composition Operators
+
+```python
+# Sequential: state_a >> state_b
+# Parallel: state_a | state_b
+# Conditional: state_a.when(predicate) >> state_b
+# Join: (state_a | state_b).join(mode="all") >> merge_state
+```
+
+### State Executors
+
+```python
+from rlm.adapters.relay.states import (
+    FunctionStateExecutor,   # Pure Python callables
+    LLMStateExecutor,        # LLM calls via LLMPort
+    AsyncStateExecutor,      # Async callables
+    RLMStateExecutor,        # Full agent orchestration
+)
+from rlm.adapters.relay.states.pipeline_state import (
+    SyncPipelineStateExecutor,   # Nested pipeline (sync)
+    AsyncPipelineStateExecutor,  # Nested pipeline (async)
+)
+```
+
+### Pipeline Executors
+
+```python
+from rlm.adapters.relay.executors import SyncPipelineExecutor, AsyncPipelineExecutor
+
+executor = SyncPipelineExecutor(pipeline)
+result = executor.run(Baton(payload="input"))
+```
+
+### Pipeline Registry
+
+```python
+from rlm.domain.relay import InMemoryPipelineRegistry, PipelineTemplate
+from rlm.application.relay import RootAgentComposer
+
+registry = InMemoryPipelineRegistry()
+registry.register(PipelineTemplate(name="research", ...))
+
+composer = RootAgentComposer(registry=registry, llm=llm_port)
+pipeline = composer.compose_from_registry("analyze this codebase")
+```

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/architecture.md

@@ -4,23 +4,23 @@ RLM implements a **hexagonal modular monolith** (ports & adapters) architecture
 
 ## Overview
 
-```
+```bash
 ┌─────────────────────────────────────────────────────────────────┐
-│                         API Layer                                │
+│                         API Layer                               │
 │                  (RLM, create_rlm, factories)                   │
-│                    Composition Root                              │
+│                    Composition Root                             │
 ├─────────────────────────────────────────────────────────────────┤
-│                     Application Layer                            │
-│              (use cases, configuration DTOs)                     │
+│                     Application Layer                           │
+│              (use cases, configuration DTOs)                    │
 ├─────────────────────────────────────────────────────────────────┤
-│                       Domain Layer                               │
-│        (orchestrator, ports, models — zero dependencies)         │
+│                       Domain Layer                              │
+│        (orchestrator, ports, models — zero dependencies)        │
 ├─────────────────────────────────────────────────────────────────┤
-│                      Adapters Layer                              │
-│     (LLM providers, environments, tools, broker, logger)         │
+│                      Adapters Layer                             │
+│     (LLM providers, environments, tools, broker, logger)        │
 ├─────────────────────────────────────────────────────────────────┤
-│                    Infrastructure Layer                          │
-│            (wire protocol, comms, execution policy)              │
+│                    Infrastructure Layer                         │
+│            (wire protocol, comms, execution policy)             │
 └─────────────────────────────────────────────────────────────────┘
 ```
 
@@ -42,6 +42,7 @@ Dependencies **must point inward**:
 - **Ports** (`ports.py`, `agent_ports.py`): Protocol definitions (interfaces)
 - **Models** (`models/`): Domain value objects (`ChatCompletion`, `LLMRequest`, `Iteration`, etc.)
 - **Services** (`services/`): Core orchestrator and prompt builders
+- **Relay** (`relay/`): Pipeline DSL — states, baton, validation, composition, registry
 - **Errors** (`errors.py`): Domain exception hierarchy
 - **Types** (`types.py`): Type aliases and literals
 
@@ -65,6 +66,7 @@ Dependencies **must point inward**:
 **Contents**:
 - **Config** (`config.py`): Dataclass-based configuration (`RLMConfig`, `LLMConfig`, etc.)
 - **Use Cases** (`use_cases/`): Application-level orchestration
+- **Relay** (`relay/`): Pipeline registry composer (`RootAgentComposer`)
 
 **Key Use Case**: `run_completion(request, deps)`
 
@@ -94,7 +96,7 @@ Dependencies **must point inward**:
 **Purpose**: Concrete implementations of domain ports.
 
 **Structure**:
-```
+```bash
 adapters/
 ├── llm/              # LLM provider adapters
 │   ├── openai.py
@@ -103,12 +105,18 @@ adapters/
 │   ├── azure_openai.py
 │   ├── litellm.py
 │   ├── portkey.py
-│   └── mock.py
+│   ├── mock.py
+│   └── retry.py      # Exponential backoff retry strategy
 ├── environments/     # Code execution environments
 │   ├── local.py
 │   ├── docker.py
 │   ├── modal.py      # stub
 │   └── prime.py      # stub
+├── relay/            # Pipeline executors and state implementations
+│   ├── executors/    # Sync/async pipeline orchestrators
+│   ├── states/       # Function, LLM, RLM, async, pipeline state executors
+│   ├── nested_handler.py  # Nested call policy for relay
+│   └── retry.py      # Retry strategy for state executors
 ├── tools/            # Tool calling infrastructure
 │   ├── registry.py
 │   └── native.py
@@ -156,14 +164,15 @@ RLM supports two agent paradigms:
 
 LLM generates Python code in ` ```repl ` blocks:
 
-```
+```bash
 User: What is 6 * 7?
 
 LLM: Let me calculate that.
-```repl
-result = 6 * 7
-print(f"The answer is {result}")
-```
+
+# ```repl
+# result = 6 * 7
+# print(f"The answer is {result}")
+# ```
 
 LLM: FINAL(42)
 ```
@@ -178,7 +187,7 @@ LLM: FINAL(42)
 
 LLM invokes registered tools via function calling:
 
-```
+```bash
 User: What's the weather in Tokyo?
 
 LLM: [calls get_weather(city="Tokyo")]
@@ -233,7 +242,7 @@ class NestedCallPolicy(Protocol):
 
 ## Request Flow
 
-```
+```bash
 ┌──────────┐    ┌─────────┐    ┌─────────────┐    ┌─────────────┐
 │  User    │───▶│   RLM   │───▶│  Use Case   │───▶│ Orchestrator│
 │          │    │ (Facade)│    │             │    │             │
@@ -289,7 +298,7 @@ The architecture enables comprehensive testing:
 
 ## Directory Structure
 
-```
+```bash
 src/rlm/
 ├── __init__.py              # Public exports
 ├── _meta.py                 # Version info
@@ -306,12 +315,24 @@ src/rlm/
 │   │   ├── llm_request.py
 │   │   ├── iteration.py
 │   │   └── ...
+│   ├── relay/               # Pipeline DSL (states, baton, validation, composition)
+│   │   ├── state.py         # StateSpec with operator overloading
+│   │   ├── pipeline.py      # Pipeline builder and graph definition
+│   │   ├── baton.py         # Immutable request-response envelope
+│   │   ├── validation.py    # Type/reachability/cycle validation
+│   │   ├── composition.py   # ComposablePipeline, WorkflowSeed
+│   │   ├── registry.py      # PipelineTemplate, PipelineRegistry
+│   │   ├── budget.py        # TokenBudget tracking
+│   │   ├── trace.py         # PipelineTrace audit log
+│   │   └── ...
 │   └── services/
 │       ├── rlm_orchestrator.py
 │       └── prompts.py
 │
 ├── application/             # USE CASES
 │   ├── config.py            # Configuration DTOs
+│   ├── relay/               # Pipeline registry composer
+│   │   └── root_composer.py # LLM-assisted pipeline selection
 │   └── use_cases/
 │       └── run_completion.py
 │
@@ -373,5 +394,6 @@ See [Architecture Decision Records](adr/) for rationale:
 - [API Reference](api-reference.md) — Public API documentation
 - [Configuration](configuration.md) — All configuration options
 - [Extension Protocols](extending/extension-protocols.md) — Custom policies
+- [Relay Pipeline](relay/overview.md) — Pipeline DSL and composition
 - [Internals: Ports](internals/ports.md) — Port interface details
 - [Internals: Protocol](internals/protocol.md) — Wire protocol specification

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/configuration.md

@@ -296,10 +296,10 @@ config = RLMConfig(
 The LLM generates code in ` ```repl ` blocks that get executed:
 
 ```python
-```repl
-result = 2 + 2
-print(result)
-```
+# ```repl
+# result = 2 + 2
+# print(result)
+# ```
 ```
 
 ### Tools Mode

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/contributing/commit-conventions.md

@@ -4,7 +4,7 @@ RLM follows [Conventional Commits](https://www.conventionalcommits.org/) for con
 
 ## Format
 
-```
+```bash
 type(scope): subject
 
 - Bullet point explaining what and why

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/environments/execution-environments.md

@@ -19,24 +19,24 @@ The local environment executes Python code in **isolated subprocess workers** (v
 
 ### Architecture
 
-```
+```bash
 ┌─────────────────────────────────────────────┐
-│             Parent Process                   │
-│  ┌─────────────┐    ┌──────────────────┐   │
-│  │ RLM         │    │ Broker           │   │
-│  │ Orchestrator│◄───│ (llm_query)      │   │
-│  └─────────────┘    └──────────────────┘   │
+│             Parent Process                  │
+│  ┌─────────────┐    ┌──────────────────┐    │
+│  │ RLM         │    │ Broker           │    │
+│  │ Orchestrator│◄───│ (llm_query)      │    │
+│  └─────────────┘    └──────────────────┘    │
 │         │                   ▲               │
 │         │ spawn             │ IPC           │
 │         ▼                   │               │
-│  ┌──────────────────────────┴──────────┐   │
-│  │         Worker Subprocess            │   │
-│  │  ┌─────────────────────────────┐    │   │
-│  │  │     Isolated Namespace      │    │   │
-│  │  │  - Code execution           │    │   │
-│  │  │  - llm_query() → parent IPC │    │   │
-│  │  └─────────────────────────────┘    │   │
-│  └─────────────────────────────────────┘   │
+│  ┌──────────────────────────┴──────────┐    │
+│  │         Worker Subprocess           │    │
+│  │  ┌─────────────────────────────┐    │    │
+│  │  │     Isolated Namespace      │    │    │
+│  │  │  - Code execution           │    │    │
+│  │  │  - llm_query() → parent IPC │    │    │
+│  │  └─────────────────────────────┘    │    │
+│  └─────────────────────────────────────┘    │
 └─────────────────────────────────────────────┘
 ```
 
@@ -129,25 +129,25 @@ config = RLMConfig(
 
 ### Architecture
 
-```
+```bash
 ┌─────────────────────────────────────────────┐
 │                Host Process                 │
 │                                             │
-│  ┌─────────────┐    ┌──────────────────┐   │
-│  │ RLM         │    │ HTTP Proxy       │   │
-│  │ Orchestrator│◄───│ (llm_query)      │   │
-│  └─────────────┘    └──────────────────┘   │
+│  ┌─────────────┐    ┌──────────────────┐    │
+│  │ RLM         │    │ HTTP Proxy       │    │
+│  │ Orchestrator│◄───│ (llm_query)      │    │
+│  └─────────────┘    └──────────────────┘    │
 │         │                   ▲               │
 │         │ docker exec       │ HTTP          │
 │         ▼                   │               │
-│  ┌──────────────────────────┴──────────┐   │
-│  │           Docker Container           │   │
-│  │  ┌─────────────────────────────┐    │   │
-│  │  │     Python Runtime          │    │   │
-│  │  │  - context variable         │    │   │
-│  │  │  - llm_query() → HTTP proxy │    │   │
-│  │  └─────────────────────────────┘    │   │
-│  └─────────────────────────────────────┘   │
+│  ┌──────────────────────────┴──────────┐    │
+│  │           Docker Container          │    │
+│  │  ┌─────────────────────────────┐    │    │
+│  │  │     Python Runtime          │    │    │
+│  │  │  - context variable         │    │    │
+│  │  │  - llm_query() → HTTP proxy │    │    │
+│  │  └─────────────────────────────┘    │    │
+│  └─────────────────────────────────────┘    │
 └─────────────────────────────────────────────┘
 ```
 

{agentic_codebase_navigator-1.2.0 → agentic_codebase_navigator-1.3.1}/docs/internals/logging.md

@@ -1,4 +1,4 @@
-# Logging (Phase 06)
+# Logging
 
 RLM supports **optional run logging** through the domain `LoggerPort`.