Operational Terms Glossary

Terms related to SCHEMABOUND’s runtime infrastructure, event publishing pipeline, self-healing workers, and observability systems. These terms are relevant when configuring the EventBus, tuning Auto-Rewind workers, setting up audit logging, or integrating with SIEM platforms.

Auto-Rewind Worker

A background data resilience worker in SCHEMABOUND that handles historical schema replay and topology refresh. When a table’s schema changes (columns added, indexes modified), Auto-Rewind replays the change through all dependent components — local mappers, TCP mappers, injection guard caches — ensuring consistency across the runtime without manual intervention.

Chain of Responsibility (CoR)

The handler pattern implemented by SCHEMABOUND’s EventBus. Every domain event — query execution, validation failures, session registration, trigger fires — flows through a registered sequence of handlers before any subscribers see it. Built-in CoR handlers include AuditLogHandler, QueryMetricsHandler, and SessionActivityHandler. Custom handlers can be registered via the SharedHandler trait.

See also: EventBus, Chain Integrity Verification

Chain Integrity Verification

A background worker that verifies the tamper-evident SHA-256 hash chain maintained by SCHEMABOUND’s audit logging pipeline. Each AuditEventEnvelope carries a sequence number and prev_hash; this worker periodically anchors verification at configurable depths (SCHEMABOUND_CHAIN_VERIFY_ANCHOR_DEPTH) to detect any tampering in the event stream before it reaches SIEM platforms.

See also: Auto-Rewind Worker, Audit Log Handler

Data Resilience Workers

The collective term for background workers that maintain SCHEMABOUND’s operational integrity: Auto-Rewind (schema topology refresh and historical replay) and Chain Integrity Verification (SHA-256 hash chain validation). Both run as independent goroutines with configurable exponential backoff (RESTART_BASE_DELAY_SECONDS) and are managed by the self-healing infrastructure health checker state machine.

EventBus

The typed event bus at the center of SCHEMABOUND’s runtime architecture. All domain events flow through the EventBus before reaching handlers or subscribers. Events are strongly-typed Rust enums (Event::QueryExecuted, Event::PlanCreated, etc.) that carry structured payloads; handlers implement the EventHandler trait and return a HandleOutcome indicating whether processing should continue down the chain.

Governance Cost Model

The principle that every tool call in SCHEMABOUND carries a governance cost proportional to its risk profile. Implemented via AAU intent classification (Read=1x, Write=3x, Governed=5x); enforced through policy evaluation before any query reaches the mapper layer. Total AAU consumed per session determines billing tier thresholds and rate limit windows.

Llm Tool Call Audit Recorded Event

The core audit event emitted by SCHEMABOUND when a tool call completes (success or failure). Carries the full execution context: session ID, user identity, organization, traceparent W3C headers, tool name, intent classification, AAU weight, query template, result row count, and execution time. This event is what AuditLogHandler transforms into OCSF v1.1 format for SIEM export.

See also: EventBus, OCSF Format

MultiTransport Exporter

The fan-out mechanism that exports audit events to multiple destinations simultaneously. Configured via environment variables: SCHEMABOUND_AUDIT_LOG_DIR (rotating log files), SCHEMABOUND_AUDIT_WEBHOOK_URL (HTTP webhooks to SIEM platforms), and stderr for local development. The exporter is idempotent — if one destination fails, others still receive the event; failures are logged but never block the primary execution path.

See also: EventBus, OCSF Format

Query Metrics Handler

A built-in Chain of Responsibility handler that tracks query execution metrics for AAU billing and performance monitoring. Records: total queries per session, AAU consumed per intent type (read/write/governed), average execution time by tool name, and rate limit hits. Metrics are aggregated into the AAU Dashboard viewable at /billing/usage and exportable via the D3.js heatmap component for ORM model × intent cost analysis.

See also: Agentic Activity Unit, AAU Dashboard

Self-Healing Infrastructure

SCHEMABOUND’s automatic recovery mechanism for background workers and connection failures. Uses a health checker state machine that monitors Auto-Rewind and Chain Integrity worker liveness; on failure, triggers exponential backoff retry (RESTART_BASE_DELAY_SECONDS, max 5 attempts before escalating to operator alert). The state machine is topology-aware: it consults the schema graph during recovery to ensure dependent components are restarted in correct order.

Session Activity Handler

A built-in Chain of Responsibility handler that captures per-session memory entries for SCHEMABOUND’s Agent Memory feature. Records observations, tool call results, and decision points as chronological history scoped to a session ID; history is retrievable via {{memory_context}} in prompt hooks so agents carry prior context across invocations without manual serialization.

See also: Agent Memory, Prompt Augmentation

Tool Contract Policy Engine

The component that evaluates tool-call contracts against registered policies before execution. Determines intent classification (read_select, write_insert, admin), applies AAU weighting based on intent, and enforces governance rules (approval workflows for governed intents, rate limits per organization). Policies are loaded at startup from SCHEMABOUND_POLICY_DIR and hot-reloaded on change without restart.

Keyboard shortcuts

SCHEMABOUND Framework Documentation