You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2026/10/10 10:24:32 UTC

(camel) branch main updated: CAMEL-25499: Add semantic auditing with CLI, TUI and MCP inspection

This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/main by this push:
     new 1972108922f1 CAMEL-25499: Add semantic auditing with CLI, TUI and MCP inspection
1972108922f1 is described below

commit 1972108922f14515638da68b857f824244898c06
Author: Luigi De Masi <55...@users.noreply.github.com>
AuthorDate: Sat Oct 10 12:24:24 2026 +0200

    CAMEL-25499: Add semantic auditing with CLI, TUI and MCP inspection
    
    Semantic evaluations exposed metadata and interactive results but had no
    retained history or pluggable audit delivery. This adds opt-in audit
    capture, retrieved through camel semantic audit, the Semantic TUI Audit
    view and the tui_get_audit MCP tool.
    
    Evaluation records keep the typed result and its meaning, the provider
    identity, allowlisted model and revision strings, and start and
    completion times. Routes record their actions explicitly and link the
    supporting evidence. Submitted content, headers, arbitrary provider
    metadata and raw exceptions are not recorded.
    
    There are separate sink and reader SPIs, a bounded in-memory history and
    JSON logging, with asynchronous best-effort delivery that reports drops,
    evictions and backend errors. Auditing is configured in the YAML, XML
    and Java DSL with a global default and per-expert overrides. The dev
    console, the CLI connector and the CLI query by exact filters with cursor
    pages. Observation hooks allow telemetry without coupling capture to
    trace sampling. The design is in design/semantic-audit.adoc.
    
    Closes #27649
    
    Co-authored-by: OpenAI Codex <no...@openai.com>
---
 .../apache/camel/catalog/dev-consoles-openapi.json | 110 ++++
 .../apache/camel/catalog/dev-consoles.properties   |   1 +
 .../camel/catalog/dev-consoles/semantic-audit.json | 159 ++++++
 .../camel/catalog/docs/semantic-language.adoc      | 260 +++++++++
 .../camel/catalog/schemas/camelYamlDsl-model.json  |  90 +++
 .../apache/camel/dev-console/semantic-audit.json   | 159 ++++++
 .../org/apache/camel/dev-console/semantic-audit    |   2 +
 .../org/apache/camel/dev-consoles.properties       |   2 +-
 .../src/main/docs/semantic-language.adoc           | 260 +++++++++
 .../camel/language/semantic/SemanticLanguage.java  | 149 ++++-
 .../camel/semantic/LoggingSemanticAuditSink.java   |  32 ++
 .../camel/semantic/MemorySemanticAuditStore.java   | 126 +++++
 .../org/apache/camel/semantic/SemanticAudit.java   |  44 ++
 .../camel/semantic/SemanticAuditConfiguration.java |  98 ++++
 .../camel/semantic/SemanticAuditConsole.java       | 125 +++++
 .../camel/semantic/SemanticAuditDecision.java      |  58 ++
 .../apache/camel/semantic/SemanticAuditPage.java   |  50 ++
 .../apache/camel/semantic/SemanticAuditQuery.java  |  81 +++
 .../apache/camel/semantic/SemanticAuditReader.java |  45 ++
 .../apache/camel/semantic/SemanticAuditRecord.java | 195 +++++++
 .../apache/camel/semantic/SemanticAuditSink.java   |  28 +
 .../camel/semantic/SemanticEvaluateConsole.java    |  13 +-
 .../apache/camel/semantic/SemanticEvaluations.java |  39 +-
 .../camel/semantic/SemanticEvaluationsBuilder.java |   9 +-
 .../apache/camel/semantic/SemanticObserver.java    |  46 ++
 .../camel/semantic/SemanticReloadPlugin.java       |   2 +
 .../semantic/SemanticXmlRoutesBuilderLoader.java   |  71 ++-
 .../semantic/internal/SemanticAuditService.java    | 540 ++++++++++++++++++
 .../yaml/SemanticDefinitionDeserializer.java       | 189 +++++--
 .../camel/semantic/SemanticAuditConsoleTest.java   | 236 ++++++++
 .../semantic/SemanticAuditRegressionTest.java      | 312 +++++++++++
 .../camel/semantic/SemanticAuditReviewTest.java    | 219 ++++++++
 .../apache/camel/semantic/SemanticAuditTest.java   | 603 +++++++++++++++++++++
 design/semantic-audit.adoc                         |  56 ++
 .../modules/ROOT/pages/camel-jbang-managing.adoc   |  52 +-
 .../ROOT/pages/camel-jbang-tui-observe.adoc        |  17 +
 .../jbang-commands/camel-jbang-semantic-audit.adoc |  37 ++
 .../pages/jbang-commands/camel-jbang-semantic.adoc |   1 +
 .../camel/cli/connector/LocalCliConnector.java     |  44 +-
 .../LocalCliConnectorSemanticLifecycleTest.java    |  23 +-
 .../META-INF/camel-jbang-commands-metadata.json    |   2 +-
 .../dsl/jbang/core/commands/CamelJBangMain.java    |   3 +-
 .../jbang/core/commands/action/CamelSemantic.java  |   3 +-
 .../jbang/core/commands/action/SemanticAudit.java  | 176 ++++++
 .../dsl/jbang/core/commands/ai/AppFeatures.java    |   8 +
 .../dsl/jbang/core/commands/ai/ToolGroup.java      |   4 +-
 .../dsl/jbang/core/commands/ai/ToolGroups.java     |   6 +
 .../core/commands/action/SemanticCommandTest.java  | 172 +++++-
 .../camel/dsl/jbang/core/commands/tui/AiPanel.java |  12 +-
 .../dsl/jbang/core/commands/tui/McpFacade.java     |   7 +
 .../jbang/core/commands/tui/SemanticAuditView.java | 550 +++++++++++++++++++
 .../dsl/jbang/core/commands/tui/SemanticTab.java   |  73 ++-
 .../core/commands/tui/TuiToolDefinitions.java      |  16 +
 .../dsl/jbang/core/commands/tui/TuiToolGroups.java |   3 +
 .../jbang/core/commands/tui/TuiToolRegistry.java   |  55 +-
 .../src/main/resources/tui/help/semantic.md        |  30 +-
 .../core/commands/tui/AiPanelPromptBudgetTest.java |  16 +
 .../dsl/jbang/core/commands/tui/AiPanelTest.java   |   8 +-
 .../core/commands/tui/AiPanelToolGroupsTest.java   |  22 +-
 .../jbang/core/commands/tui/SemanticTabTest.java   | 190 ++++++-
 .../dsl/yaml/validator/SemanticSchemaTest.java     |   5 +
 .../resources/schema/camelYamlDsl-canonical.json   | 102 ++++
 .../resources/schema/camelYamlDsl-model.json       |  90 +++
 .../generated/resources/schema/camelYamlDsl.json   | 102 ++++
 .../camel/dsl/yaml/SemanticEvaluationTest.java     |  68 +++
 65 files changed, 6191 insertions(+), 115 deletions(-)

diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles-openapi.json b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles-openapi.json
index bc39ea57c610..1bfbf908ff0c 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles-openapi.json
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles-openapi.json
@@ -7051,6 +7051,116 @@
 				}
 			}
 		},
+		"\/q\/dev\/semantic-audit": {
+			"get": {
+				"summary": "Semantic Audit",
+				"description": "Browse retained semantic audit records",
+				"operationId": "semantic-audit",
+				"parameters": [
+					{
+						"name": "action",
+						"in": "query",
+						"description": "Filter by explicit route action",
+						"required": false,
+						"schema": {
+							"type": "string"
+						}
+					},
+					{
+						"name": "category",
+						"in": "query",
+						"description": "Filter by category",
+						"required": false,
+						"schema": {
+							"type": "string"
+						}
+					},
+					{
+						"name": "correlationId",
+						"in": "query",
+						"description": "Filter by application correlation ID",
+						"required": false,
+						"schema": {
+							"type": "string"
+						}
+					},
+					{
+						"name": "cursor",
+						"in": "query",
+						"description": "Backend cursor for an older page",
+						"required": false,
+						"schema": {
+							"type": "string"
+						}
+					},
+					{
+						"name": "eventId",
+						"in": "query",
+						"description": "Event ID to inspect with its linked evaluation records",
+						"required": false,
+						"schema": {
+							"type": "string"
+						}
+					},
+					{
+						"name": "expert",
+						"in": "query",
+						"description": "Filter by expert bean reference",
+						"required": false,
+						"schema": {
+							"type": "string"
+						}
+					},
+					{
+						"name": "limit",
+						"in": "query",
+						"description": "Maximum records, between 1 and 200",
+						"required": false,
+						"schema": {
+							"type": "integer",
+							"default": 50
+						}
+					},
+					{
+						"name": "namespace",
+						"in": "query",
+						"description": "Filter by application namespace",
+						"required": false,
+						"schema": {
+							"type": "string"
+						}
+					},
+					{
+						"name": "routeId",
+						"in": "query",
+						"description": "Filter by route",
+						"required": false,
+						"schema": {
+							"type": "string"
+						}
+					},
+					{
+						"name": "since",
+						"in": "query",
+						"description": "UTC earliest timestamp in ISO-8601 format",
+						"required": false,
+						"schema": {
+							"type": "string"
+						}
+					}
+				],
+				"responses": {
+					"200": {
+						"description": "Semantic Audit output",
+						"content": {
+							"application\/json": {
+								
+							}
+						}
+					}
+				}
+			}
+		},
 		"\/q\/dev\/semantic-evaluate": {
 			"post": {
 				"summary": "Semantic Evaluation",
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles.properties b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles.properties
index bbb2460fc158..2a74e05b95f8 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles.properties
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles.properties
@@ -61,6 +61,7 @@ route-dump
 route-group
 route-structure
 route-topology
+semantic-audit
 semantic-evaluate
 semantic-metadata
 send
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles/semantic-audit.json b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles/semantic-audit.json
new file mode 100644
index 000000000000..eb14a3bf87c2
--- /dev/null
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/dev-consoles/semantic-audit.json
@@ -0,0 +1,159 @@
+{
+  "console": {
+    "kind": "console",
+    "group": "camel",
+    "name": "semantic-audit",
+    "title": "Semantic Audit",
+    "description": "Browse retained semantic audit records",
+    "deprecated": false,
+    "readOnly": true,
+    "javaType": "org.apache.camel.semantic.SemanticAuditConsole",
+    "groupId": "org.apache.camel",
+    "artifactId": "camel-semantic",
+    "version": "4.23.0-SNAPSHOT"
+  },
+  "options": {
+    "action": {
+      "index": 0,
+      "kind": "option",
+      "displayName": "Action",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by explicit route action"
+    },
+    "category": {
+      "index": 1,
+      "kind": "option",
+      "displayName": "Category",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by category"
+    },
+    "correlationId": {
+      "index": 2,
+      "kind": "option",
+      "displayName": "Correlation Id",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by application correlation ID"
+    },
+    "cursor": {
+      "index": 3,
+      "kind": "option",
+      "displayName": "Cursor",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Backend cursor for an older page"
+    },
+    "eventId": {
+      "index": 4,
+      "kind": "option",
+      "displayName": "Event Id",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Event ID to inspect with its linked evaluation records"
+    },
+    "expert": {
+      "index": 5,
+      "kind": "option",
+      "displayName": "Expert",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by expert bean reference"
+    },
+    "limit": {
+      "index": 6,
+      "kind": "option",
+      "displayName": "Limit",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "integer",
+      "javaType": "java.lang.Integer",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "defaultValue": 50,
+      "description": "Maximum records, between 1 and 200"
+    },
+    "namespace": {
+      "index": 7,
+      "kind": "option",
+      "displayName": "Namespace",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by application namespace"
+    },
+    "routeId": {
+      "index": 8,
+      "kind": "option",
+      "displayName": "Route Id",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by route"
+    },
+    "since": {
+      "index": 9,
+      "kind": "option",
+      "displayName": "Since",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "UTC earliest timestamp in ISO-8601 format"
+    }
+  }
+}
+
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/semantic-language.adoc b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/semantic-language.adoc
index ca271702ccc3..37c8f1cb7abb 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/semantic-language.adoc
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/semantic-language.adoc
@@ -928,3 +928,263 @@ receive a busy response. A timeout or interrupted caller requests cancellation b
 worker. Providers may continue remote or native inference after interruption, so configure their own
 timeouts too. The CLI connector runs evaluations independently of its action and snapshot threads;
 responses remain associated with the originating request.
+
+
+== Auditing semantic evaluations
+
+The semantic DSL can enable an audit trail independently of telemetry and independently
+of whether a TUI is connected. Declare audit configuration in one semantic resource.
+The default is disabled. A configured expert's explicit `enabled` value overrides the
+master default in either direction; omitted values inherit it. Names refer to registry
+bean instances, so two instances of the same expert can have different audit settings.
+
+For existing expert beans named `security` and `decisions`:
+
+[source,yaml]
+----
+- semantic:
+    audit:
+      enabled: true
+      experts:
+        security:
+          enabled: true
+        decisions:
+          enabled: false
+      sinks: [memory, log]
+      reader: memory
+      capacity: 1000
+      queueCapacity: 1000
+    evaluation:
+      screenPrompt:
+        expert: security
+        operation: injection
+        state: "${body}"
+      chooseDepartment:
+        expert: decisions
+        operation: choice
+        state: "${body}"
+        parameters:
+          instructions: Choose the department for this request
+          criteria:
+            sales: Sales inquiries
+            support: Technical support
+----
+
+This records `security` evaluations and omits `decisions` evaluations. Both experts
+still execute. Changing the master to `false` continues recording `security` because
+its explicit `true` overrides the default. Removing that override restores inheritance.
+Application properties may supply DSL placeholders, for example `enabled: "{{audit.enabled:false}}"`.
+There is no second, property-based audit configuration hierarchy.
+Audit settings are fixed when the audit service starts with the context, not when it is first registered.
+Editing or removing the audit block in an existing resource is rejected if it would change those settings.
+Deleting its file removes that file's evaluation declarations and logs one warning while retaining the
+active audit configuration. Unrelated reloads continue, and a renamed resource may redeclare the same
+configuration. Stop the context, update its declarations, and start it to apply different settings.
+Backends are resolved again on startup. A changed memory capacity creates an empty store and invalidates
+old cursors; unchanged capacity retains its history across an in-place restart. Retained history is not erased by a query.
+Unknown backend references fail startup. Expert overrides can name beans registered
+later and do not instantiate experts; misspelled references never match an invocation.
+
+OpenTelemetry remains separately configured. For example, use the existing Camel Main
+`camel.opentelemetry2.enabled=false` setting with the audit block above to run auditing
+without the OpenTelemetry tracer.
+
+The Java declaration helper accepts the same immutable configuration:
+
+[source,java]
+----
+semanticEvaluations(this)
+    .audit(new SemanticAuditConfiguration(true, Map.of("security", true, "decisions", false),
+        List.of("memory", "log"), "memory", 1000, 1000))
+    .evaluation("screenPrompt").expert("security").operation("injection").end()
+    .register();
+----
+
+XML declarations use an `audit` child of `semantic`:
+
+[source,xml]
+----
+<semantic xmlns="http://camel.apache.org/schema/semantic">
+  <audit enabled="true" reader="memory" capacity="1000" queueCapacity="1000">
+    <expert name="security" enabled="true"/>
+    <expert name="decisions" enabled="false"/>
+    <sink ref="memory"/>
+    <sink ref="log"/>
+  </audit>
+  <evaluation name="screenPrompt" expert="security" operation="injection"/>
+</semantic>
+----
+
+=== Recording a route decision
+
+Evaluation records describe what the expert reported. They do not assert that a route
+allowed, blocked, quarantined or otherwise acted on a message. Record that action explicitly
+at the point where the route applies its policy, using `SemanticAuditDecision` as a
+normal Camel processor/bean, or `SemanticAudit.get(context).decision(...)` in Java.
+
+[source,yaml]
+----
+- beans:
+  - name: recordBlockedRequest
+    type: org.apache.camel.semantic.SemanticAuditDecision
+    properties:
+      fields:
+        action: block
+        operation: tools/call
+        target: support-request
+        namespace: default
+        reasonCode: prompt_injection
+        policyId: support-access
+        rule: injection-check
+- route:
+    from:
+      uri: direct:check-request
+      steps:
+        - choice:
+            when:
+              - expression:
+                  language:
+                    language: semantic
+                    expression: ref:screenPrompt
+                steps:
+                  - process:
+                      ref: recordBlockedRequest
+                  - stop: {}
+----
+
+The processor uses the latest invocation's `CamelSemanticAuditReferences` exchange
+property for its evidence IDs. A batch supplies the IDs of its observed members.
+An expert disabled for both audit and observation supplies no reference. Save and combine those
+IDs explicitly if a decision uses earlier invocations; set the processor's
+`evidenceProperty` to that exchange property. A Java caller can supply an empty list
+for a decision with no supporting evaluation. Explicit decisions are captured whenever the global default
+or at least one expert override enables auditing. Thus `enabled: false` with `security: {enabled: true}`
+retains both security evaluations and route decisions, including decisions without evidence. Expert overrides
+filter evaluation records; they do not select which application's actions are recorded. Disabling the global
+default and all expert overrides disables decision capture. `decisionsEnabled` reports this effective state. A reference may therefore point to an evaluation
+not retained by a particular backend; the inspector displays it as unavailable.
+
+A decision records the application's declared action, not successful execution of a
+later tool call. The immutable record is never updated by a later route branch.
+
+=== Backends and delivery
+
+`SemanticAuditSink` accepts immutable `SemanticAuditRecord` objects. Register custom
+sinks as Camel beans and list their bean names in `sinks`. `SemanticAuditReader` is a
+separate capability with bounded `query` and `get` operations; write-only sinks need not
+implement it. Choose the reader bean explicitly with `reader`. The built-in `memory` reader requires
+`memory` in `sinks`, otherwise configuration fails rather than displaying an unfed history.
+Readers can override `getAll(List<String>)` to fetch up to 100 linked evidence records with one backend
+query; the console calls it once per selected record. The default implementation delegates to `get`,
+and the memory implementation scans its bounded history once. Missing IDs remain visibly unavailable.
+The reserved backend
+names are `memory` and `log`:
+
+* `memory` is a bounded recent-history sink and reader. `capacity` defaults to 1000
+  (range 1 to 100000); old records are evicted and counted. Its history is not persistent.
+* `log` writes JSON to the `org.apache.camel.semantic.audit` logger using the application's
+  normal logging configuration. Logging does not provide a query reader.
+
+The supported backend APIs are `SemanticAuditSink`, `SemanticAuditReader`, `SemanticAuditRecord`,
+`SemanticAuditQuery` and `SemanticAuditPage`. Record maps use a validated, bounded version-1 serialization
+schema; typed timestamp, duration and evidence accessors avoid backend casts. `query.matches(record)`
+provides exact case-sensitive AND filtering with an inclusive timestamp boundary. Record field order
+is preserved for structured logging. Classes in `org.apache.camel.semantic.internal` are runtime plumbing,
+not a supported integration API. Routes use `SemanticAuditDecision` or `SemanticAudit` and its documented
+`REFERENCES` property; observers use `SemanticObserver`.
+
+The context starts and stops its configured backends. A single worker dispatches each
+accepted record to the sinks in configuration order. `queueCapacity` defaults to 1000
+(range 1 to 100000). A full queue drops the new record and increments `dropped`;
+backend append failures increment that sink's error counter and do not change inference
+or route decisions. An append failure does not prevent trying the remaining sinks.
+A slow sink delays this dispatcher, so sink implementations must bound I/O and honor
+interruption. Shutdown allows five seconds to drain, then cancels queued work and counts
+it as dropped. Delivery can be partial and process failure can lose queued records.
+
+Returning from `append` means acceptance according to that backend's documented contract;
+it does not universally mean durable commit. The dispatcher does not retry failed writes.
+Backend-specific retries must retain the event ID. This mode does not guarantee a durable
+record before a protected side effect. Persistent implementations can reconstruct the
+versioned immutable snapshot with `SemanticAuditRecord.fromMap`.
+
+=== Records and observations
+
+Version 1 records contain UTC occurrence timestamps, unique event and invocation IDs,
+plus `startedAt` for evaluations. An evaluation's `timestamp` denotes completion; the start observer
+sees the start occurrence in `timestamp`, and `startedAt` stays unchanged in the completed record.
+Duration uses the monotonic clock. Records also contain
+category, configured expert reference, operation, definition and execution origin, and
+available Camel context/exchange/route identifiers. Evaluation records add execution
+status, duration, a stable reason code, typed result, probability/confidence when present,
+and the static result meanings captured at invocation time. `provider` identifies the static expert
+contract. Optional `model` and `revision` are copied only from those exact result metadata keys, only
+when they are nonblank strings of at most 256 code points without control characters. They are omitted
+rather than truncated if invalid; provider metadata cannot override the contract's provider identity.
+No other result metadata is captured. Adapters should supply the actual producing model and revision
+when known; absent identity stays absent. Batch members have individual
+invocation IDs and a shared batch ID. A failed group and groups never executed are distinct.
+Input validation completes before inference: a member whose input passed but whose sibling failed validation
+is `not_executed`. When a provider returns a complete batch, each returned answer is validated and audited
+independently, even if a sibling answer is invalid. The route still receives a batch failure and no partial
+result/diagnostic map. A valid answer is evidence of evaluation, not a successful batch or route action.
+Console cancellation requests are separate records linked to eventual provider completion:
+request timeout does not prove that native or remote inference stopped. A timeout
+before an expert is resolved emits no request record because its audit eligibility
+is not yet known. Declaration failures without an identifiable expert also omit an
+evaluation record; failures with a known reference follow that expert's override.
+
+Decision records carry explicit action, operation, target, optional namespace/correlation
+and policy identifiers, reason code and evidence IDs. They never derive application
+correlation or tenant identity from arbitrary inbound headers.
+
+Input, body, headers, variables, arbitrary provider metadata and exception messages are
+omitted before dispatch to any backend or observer. Caller-authored score descriptions
+are also omitted; the UI does not substitute today's definition for missing historical
+semantics. Strings are limited to 256 code points and collections to 100 entries.
+Oversized result snapshots are omitted with `resultOmitted: snapshot_limit`, preserving
+the execution status without displaying altered labels or partial probabilities. These records are evidence about
+an evaluation and declared action, not a copy of the submitted content.
+
+Register `SemanticObserver` beans to consume start/completion and explicit decision
+hooks independently of auditing. Beans must be registered before context startup: observers are
+discovered once when the audit service starts; later registrations take effect after restarting it.
+Observer completion runs in reverse start-callback order; registry registration order is not a contract.
+Observer failures do not replace an expert result or
+route action. Callbacks must not block. `captureContext` runs before a console executor
+handoff. Observations remain detached between callbacks: start spans with the supplied
+parent explicitly, and restore any temporary thread context before returning from each
+callback. This prevents overlapping batch observations from corrupting a thread's scope.
+The observer implementation owns its tracing lifecycle.
+The generic semantic module has no OpenTelemetry dependency or SDK/exporter configuration.
+An OpenTelemetry integration should reuse Camel's configured telemetry infrastructure;
+trace sampling must not determine whether audit records are stored. This SPI supplies
+hooks and does not install an OpenTelemetry exporter or bind Camel to draft guardrail
+semantic-convention names.
+
+=== Browsing history
+
+Use `camel semantic audit my-app` to retrieve a table of retained records from the
+xref:manual::camel-jbang-managing.adoc#_semantic_audit_history[Camel CLI]. Add `--json` for
+machine-readable output, or `--event-id=EVENT_ID` to inspect a record and its linked evidence.
+The CLI uses the same reader, filters and cursors as the console and TUI.
+
+The read-only `semantic-audit` developer console accepts `eventId` for a selected record
+and its evidence, or a bounded page query with `limit` (1 to 200), `cursor`, `since` (UTC
+ISO-8601), `category`, `action`, `expert`, `routeId`, `namespace` and `correlationId`.
+Cursors belong to their backend and filter. Query responses report evictions, expired
+cursors, effective settings, delivery errors and dropped records. Backend error messages
+are replaced with a stable code. Querying does not evaluate a definition or require that
+an old definition still exists.
+
+The Semantic tab in xref:manual::camel-jbang-tui.adoc[Camel TUI] provides an Audit view
+with the same filters, table and linked-record inspector. `tui_get_audit` exposes this
+history through the TUI MCP server without changing the visible tab, filters, page or selection.
+Pass `eventId` alone to inspect a record and its evidence, or the console's filters, `limit` and returned
+`cursor` to query pages. TUI AI sessions load this tool only for integrations exposing the audit console,
+in both core and full tool modes. Screen navigation remains an explicit TUI action.
+`r` refreshes the current page and `g` returns to the latest page. Pending refreshes are coalesced,
+while the latest changed filter/page is queried after the active request finishes. `tui_get_table` also includes audit rows, filters,
+selected details, linked evidence and backend status when Audit is selected. The OpenTelemetry status
+recognizes both Camel OpenTelemetry tracer implementations, including subclasses. It reports the
+context tracer state; it does not claim that a semantic observer/exporter has been installed.
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camelYamlDsl-model.json b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camelYamlDsl-model.json
index ede879de9011..7472732229c7 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camelYamlDsl-model.json
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camelYamlDsl-model.json
@@ -20536,6 +20536,96 @@
     },
     "semantic" : {
       "isListItem" : true,
+      "children" : [ {
+        "name" : "evaluation",
+        "type" : "map",
+        "ref" : "semanticDefinitionDeserializer$EvaluationSchema",
+        "required" : true
+      }, {
+        "name" : "expert",
+        "type" : "string"
+      }, {
+        "name" : "state",
+        "type" : "string"
+      }, {
+        "name" : "audit",
+        "type" : "object",
+        "ref" : "semanticDefinitionDeserializer$AuditSchema",
+        "required" : true
+      } ]
+    },
+    "semanticDefinitionDeserializer$AuditDeclarationSchema" : {
+      "children" : [ {
+        "name" : "audit",
+        "type" : "object",
+        "ref" : "semanticDefinitionDeserializer$AuditSchema",
+        "required" : true
+      }, {
+        "name" : "expert",
+        "type" : "string"
+      }, {
+        "name" : "state",
+        "type" : "string"
+      } ]
+    },
+    "semanticDefinitionDeserializer$AuditExpertSchema" : {
+      "children" : [ {
+        "name" : "enabled",
+        "type" : "boolean",
+        "required" : true
+      } ]
+    },
+    "semanticDefinitionDeserializer$AuditSchema" : {
+      "children" : [ {
+        "name" : "capacity",
+        "type" : "integer"
+      }, {
+        "name" : "enabled",
+        "type" : "boolean"
+      }, {
+        "name" : "experts",
+        "type" : "map",
+        "ref" : "semanticDefinitionDeserializer$AuditExpertSchema"
+      }, {
+        "name" : "queueCapacity",
+        "type" : "integer"
+      }, {
+        "name" : "reader",
+        "type" : "string"
+      }, {
+        "name" : "sinks",
+        "type" : "array"
+      } ]
+    },
+    "semanticDefinitionDeserializer$AuditedEvaluationDeclarationSchema" : {
+      "children" : [ {
+        "name" : "audit",
+        "type" : "object",
+        "ref" : "semanticDefinitionDeserializer$AuditSchema",
+        "required" : true
+      }, {
+        "name" : "evaluation",
+        "type" : "map",
+        "ref" : "semanticDefinitionDeserializer$EvaluationSchema",
+        "required" : true
+      }, {
+        "name" : "expert",
+        "type" : "string"
+      }, {
+        "name" : "state",
+        "type" : "string"
+      } ]
+    },
+    "semanticDefinitionDeserializer$DeclarationSchema" : {
+      "children" : [ {
+        "name" : "expert",
+        "type" : "string"
+      }, {
+        "name" : "state",
+        "type" : "string"
+      } ]
+    },
+    "semanticDefinitionDeserializer$EvaluationDeclarationSchema" : {
       "children" : [ {
         "name" : "evaluation",
         "type" : "map",
diff --git a/components/camel-ai/camel-semantic/src/generated/resources/META-INF/org/apache/camel/dev-console/semantic-audit.json b/components/camel-ai/camel-semantic/src/generated/resources/META-INF/org/apache/camel/dev-console/semantic-audit.json
new file mode 100644
index 000000000000..eb14a3bf87c2
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/generated/resources/META-INF/org/apache/camel/dev-console/semantic-audit.json
@@ -0,0 +1,159 @@
+{
+  "console": {
+    "kind": "console",
+    "group": "camel",
+    "name": "semantic-audit",
+    "title": "Semantic Audit",
+    "description": "Browse retained semantic audit records",
+    "deprecated": false,
+    "readOnly": true,
+    "javaType": "org.apache.camel.semantic.SemanticAuditConsole",
+    "groupId": "org.apache.camel",
+    "artifactId": "camel-semantic",
+    "version": "4.23.0-SNAPSHOT"
+  },
+  "options": {
+    "action": {
+      "index": 0,
+      "kind": "option",
+      "displayName": "Action",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by explicit route action"
+    },
+    "category": {
+      "index": 1,
+      "kind": "option",
+      "displayName": "Category",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by category"
+    },
+    "correlationId": {
+      "index": 2,
+      "kind": "option",
+      "displayName": "Correlation Id",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by application correlation ID"
+    },
+    "cursor": {
+      "index": 3,
+      "kind": "option",
+      "displayName": "Cursor",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Backend cursor for an older page"
+    },
+    "eventId": {
+      "index": 4,
+      "kind": "option",
+      "displayName": "Event Id",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Event ID to inspect with its linked evaluation records"
+    },
+    "expert": {
+      "index": 5,
+      "kind": "option",
+      "displayName": "Expert",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by expert bean reference"
+    },
+    "limit": {
+      "index": 6,
+      "kind": "option",
+      "displayName": "Limit",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "integer",
+      "javaType": "java.lang.Integer",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "defaultValue": 50,
+      "description": "Maximum records, between 1 and 200"
+    },
+    "namespace": {
+      "index": 7,
+      "kind": "option",
+      "displayName": "Namespace",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by application namespace"
+    },
+    "routeId": {
+      "index": 8,
+      "kind": "option",
+      "displayName": "Route Id",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "Filter by route"
+    },
+    "since": {
+      "index": 9,
+      "kind": "option",
+      "displayName": "Since",
+      "group": "query",
+      "label": "query",
+      "required": false,
+      "type": "string",
+      "javaType": "java.lang.String",
+      "deprecated": false,
+      "autowired": false,
+      "secret": false,
+      "description": "UTC earliest timestamp in ISO-8601 format"
+    }
+  }
+}
+
diff --git a/components/camel-ai/camel-semantic/src/generated/resources/META-INF/services/org/apache/camel/dev-console/semantic-audit b/components/camel-ai/camel-semantic/src/generated/resources/META-INF/services/org/apache/camel/dev-console/semantic-audit
new file mode 100644
index 000000000000..2dd0b43952d7
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/generated/resources/META-INF/services/org/apache/camel/dev-console/semantic-audit
@@ -0,0 +1,2 @@
+# Generated by camel build tools - do NOT edit this file!
+class=org.apache.camel.semantic.SemanticAuditConsole
diff --git a/components/camel-ai/camel-semantic/src/generated/resources/META-INF/services/org/apache/camel/dev-consoles.properties b/components/camel-ai/camel-semantic/src/generated/resources/META-INF/services/org/apache/camel/dev-consoles.properties
index bf71896a2630..568545d10995 100644
--- a/components/camel-ai/camel-semantic/src/generated/resources/META-INF/services/org/apache/camel/dev-consoles.properties
+++ b/components/camel-ai/camel-semantic/src/generated/resources/META-INF/services/org/apache/camel/dev-consoles.properties
@@ -1,5 +1,5 @@
 # Generated by camel build tools - do NOT edit this file!
-dev-consoles=semantic-evaluate semantic-metadata
+dev-consoles=semantic-audit semantic-evaluate semantic-metadata
 groupId=org.apache.camel
 artifactId=camel-semantic
 version=4.23.0-SNAPSHOT
diff --git a/components/camel-ai/camel-semantic/src/main/docs/semantic-language.adoc b/components/camel-ai/camel-semantic/src/main/docs/semantic-language.adoc
index ca271702ccc3..37c8f1cb7abb 100644
--- a/components/camel-ai/camel-semantic/src/main/docs/semantic-language.adoc
+++ b/components/camel-ai/camel-semantic/src/main/docs/semantic-language.adoc
@@ -928,3 +928,263 @@ receive a busy response. A timeout or interrupted caller requests cancellation b
 worker. Providers may continue remote or native inference after interruption, so configure their own
 timeouts too. The CLI connector runs evaluations independently of its action and snapshot threads;
 responses remain associated with the originating request.
+
+
+== Auditing semantic evaluations
+
+The semantic DSL can enable an audit trail independently of telemetry and independently
+of whether a TUI is connected. Declare audit configuration in one semantic resource.
+The default is disabled. A configured expert's explicit `enabled` value overrides the
+master default in either direction; omitted values inherit it. Names refer to registry
+bean instances, so two instances of the same expert can have different audit settings.
+
+For existing expert beans named `security` and `decisions`:
+
+[source,yaml]
+----
+- semantic:
+    audit:
+      enabled: true
+      experts:
+        security:
+          enabled: true
+        decisions:
+          enabled: false
+      sinks: [memory, log]
+      reader: memory
+      capacity: 1000
+      queueCapacity: 1000
+    evaluation:
+      screenPrompt:
+        expert: security
+        operation: injection
+        state: "${body}"
+      chooseDepartment:
+        expert: decisions
+        operation: choice
+        state: "${body}"
+        parameters:
+          instructions: Choose the department for this request
+          criteria:
+            sales: Sales inquiries
+            support: Technical support
+----
+
+This records `security` evaluations and omits `decisions` evaluations. Both experts
+still execute. Changing the master to `false` continues recording `security` because
+its explicit `true` overrides the default. Removing that override restores inheritance.
+Application properties may supply DSL placeholders, for example `enabled: "{{audit.enabled:false}}"`.
+There is no second, property-based audit configuration hierarchy.
+Audit settings are fixed when the audit service starts with the context, not when it is first registered.
+Editing or removing the audit block in an existing resource is rejected if it would change those settings.
+Deleting its file removes that file's evaluation declarations and logs one warning while retaining the
+active audit configuration. Unrelated reloads continue, and a renamed resource may redeclare the same
+configuration. Stop the context, update its declarations, and start it to apply different settings.
+Backends are resolved again on startup. A changed memory capacity creates an empty store and invalidates
+old cursors; unchanged capacity retains its history across an in-place restart. Retained history is not erased by a query.
+Unknown backend references fail startup. Expert overrides can name beans registered
+later and do not instantiate experts; misspelled references never match an invocation.
+
+OpenTelemetry remains separately configured. For example, use the existing Camel Main
+`camel.opentelemetry2.enabled=false` setting with the audit block above to run auditing
+without the OpenTelemetry tracer.
+
+The Java declaration helper accepts the same immutable configuration:
+
+[source,java]
+----
+semanticEvaluations(this)
+    .audit(new SemanticAuditConfiguration(true, Map.of("security", true, "decisions", false),
+        List.of("memory", "log"), "memory", 1000, 1000))
+    .evaluation("screenPrompt").expert("security").operation("injection").end()
+    .register();
+----
+
+XML declarations use an `audit` child of `semantic`:
+
+[source,xml]
+----
+<semantic xmlns="http://camel.apache.org/schema/semantic">
+  <audit enabled="true" reader="memory" capacity="1000" queueCapacity="1000">
+    <expert name="security" enabled="true"/>
+    <expert name="decisions" enabled="false"/>
+    <sink ref="memory"/>
+    <sink ref="log"/>
+  </audit>
+  <evaluation name="screenPrompt" expert="security" operation="injection"/>
+</semantic>
+----
+
+=== Recording a route decision
+
+Evaluation records describe what the expert reported. They do not assert that a route
+allowed, blocked, quarantined or otherwise acted on a message. Record that action explicitly
+at the point where the route applies its policy, using `SemanticAuditDecision` as a
+normal Camel processor/bean, or `SemanticAudit.get(context).decision(...)` in Java.
+
+[source,yaml]
+----
+- beans:
+  - name: recordBlockedRequest
+    type: org.apache.camel.semantic.SemanticAuditDecision
+    properties:
+      fields:
+        action: block
+        operation: tools/call
+        target: support-request
+        namespace: default
+        reasonCode: prompt_injection
+        policyId: support-access
+        rule: injection-check
+- route:
+    from:
+      uri: direct:check-request
+      steps:
+        - choice:
+            when:
+              - expression:
+                  language:
+                    language: semantic
+                    expression: ref:screenPrompt
+                steps:
+                  - process:
+                      ref: recordBlockedRequest
+                  - stop: {}
+----
+
+The processor uses the latest invocation's `CamelSemanticAuditReferences` exchange
+property for its evidence IDs. A batch supplies the IDs of its observed members.
+An expert disabled for both audit and observation supplies no reference. Save and combine those
+IDs explicitly if a decision uses earlier invocations; set the processor's
+`evidenceProperty` to that exchange property. A Java caller can supply an empty list
+for a decision with no supporting evaluation. Explicit decisions are captured whenever the global default
+or at least one expert override enables auditing. Thus `enabled: false` with `security: {enabled: true}`
+retains both security evaluations and route decisions, including decisions without evidence. Expert overrides
+filter evaluation records; they do not select which application's actions are recorded. Disabling the global
+default and all expert overrides disables decision capture. `decisionsEnabled` reports this effective state. A reference may therefore point to an evaluation
+not retained by a particular backend; the inspector displays it as unavailable.
+
+A decision records the application's declared action, not successful execution of a
+later tool call. The immutable record is never updated by a later route branch.
+
+=== Backends and delivery
+
+`SemanticAuditSink` accepts immutable `SemanticAuditRecord` objects. Register custom
+sinks as Camel beans and list their bean names in `sinks`. `SemanticAuditReader` is a
+separate capability with bounded `query` and `get` operations; write-only sinks need not
+implement it. Choose the reader bean explicitly with `reader`. The built-in `memory` reader requires
+`memory` in `sinks`, otherwise configuration fails rather than displaying an unfed history.
+Readers can override `getAll(List<String>)` to fetch up to 100 linked evidence records with one backend
+query; the console calls it once per selected record. The default implementation delegates to `get`,
+and the memory implementation scans its bounded history once. Missing IDs remain visibly unavailable.
+The reserved backend
+names are `memory` and `log`:
+
+* `memory` is a bounded recent-history sink and reader. `capacity` defaults to 1000
+  (range 1 to 100000); old records are evicted and counted. Its history is not persistent.
+* `log` writes JSON to the `org.apache.camel.semantic.audit` logger using the application's
+  normal logging configuration. Logging does not provide a query reader.
+
+The supported backend APIs are `SemanticAuditSink`, `SemanticAuditReader`, `SemanticAuditRecord`,
+`SemanticAuditQuery` and `SemanticAuditPage`. Record maps use a validated, bounded version-1 serialization
+schema; typed timestamp, duration and evidence accessors avoid backend casts. `query.matches(record)`
+provides exact case-sensitive AND filtering with an inclusive timestamp boundary. Record field order
+is preserved for structured logging. Classes in `org.apache.camel.semantic.internal` are runtime plumbing,
+not a supported integration API. Routes use `SemanticAuditDecision` or `SemanticAudit` and its documented
+`REFERENCES` property; observers use `SemanticObserver`.
+
+The context starts and stops its configured backends. A single worker dispatches each
+accepted record to the sinks in configuration order. `queueCapacity` defaults to 1000
+(range 1 to 100000). A full queue drops the new record and increments `dropped`;
+backend append failures increment that sink's error counter and do not change inference
+or route decisions. An append failure does not prevent trying the remaining sinks.
+A slow sink delays this dispatcher, so sink implementations must bound I/O and honor
+interruption. Shutdown allows five seconds to drain, then cancels queued work and counts
+it as dropped. Delivery can be partial and process failure can lose queued records.
+
+Returning from `append` means acceptance according to that backend's documented contract;
+it does not universally mean durable commit. The dispatcher does not retry failed writes.
+Backend-specific retries must retain the event ID. This mode does not guarantee a durable
+record before a protected side effect. Persistent implementations can reconstruct the
+versioned immutable snapshot with `SemanticAuditRecord.fromMap`.
+
+=== Records and observations
+
+Version 1 records contain UTC occurrence timestamps, unique event and invocation IDs,
+plus `startedAt` for evaluations. An evaluation's `timestamp` denotes completion; the start observer
+sees the start occurrence in `timestamp`, and `startedAt` stays unchanged in the completed record.
+Duration uses the monotonic clock. Records also contain
+category, configured expert reference, operation, definition and execution origin, and
+available Camel context/exchange/route identifiers. Evaluation records add execution
+status, duration, a stable reason code, typed result, probability/confidence when present,
+and the static result meanings captured at invocation time. `provider` identifies the static expert
+contract. Optional `model` and `revision` are copied only from those exact result metadata keys, only
+when they are nonblank strings of at most 256 code points without control characters. They are omitted
+rather than truncated if invalid; provider metadata cannot override the contract's provider identity.
+No other result metadata is captured. Adapters should supply the actual producing model and revision
+when known; absent identity stays absent. Batch members have individual
+invocation IDs and a shared batch ID. A failed group and groups never executed are distinct.
+Input validation completes before inference: a member whose input passed but whose sibling failed validation
+is `not_executed`. When a provider returns a complete batch, each returned answer is validated and audited
+independently, even if a sibling answer is invalid. The route still receives a batch failure and no partial
+result/diagnostic map. A valid answer is evidence of evaluation, not a successful batch or route action.
+Console cancellation requests are separate records linked to eventual provider completion:
+request timeout does not prove that native or remote inference stopped. A timeout
+before an expert is resolved emits no request record because its audit eligibility
+is not yet known. Declaration failures without an identifiable expert also omit an
+evaluation record; failures with a known reference follow that expert's override.
+
+Decision records carry explicit action, operation, target, optional namespace/correlation
+and policy identifiers, reason code and evidence IDs. They never derive application
+correlation or tenant identity from arbitrary inbound headers.
+
+Input, body, headers, variables, arbitrary provider metadata and exception messages are
+omitted before dispatch to any backend or observer. Caller-authored score descriptions
+are also omitted; the UI does not substitute today's definition for missing historical
+semantics. Strings are limited to 256 code points and collections to 100 entries.
+Oversized result snapshots are omitted with `resultOmitted: snapshot_limit`, preserving
+the execution status without displaying altered labels or partial probabilities. These records are evidence about
+an evaluation and declared action, not a copy of the submitted content.
+
+Register `SemanticObserver` beans to consume start/completion and explicit decision
+hooks independently of auditing. Beans must be registered before context startup: observers are
+discovered once when the audit service starts; later registrations take effect after restarting it.
+Observer completion runs in reverse start-callback order; registry registration order is not a contract.
+Observer failures do not replace an expert result or
+route action. Callbacks must not block. `captureContext` runs before a console executor
+handoff. Observations remain detached between callbacks: start spans with the supplied
+parent explicitly, and restore any temporary thread context before returning from each
+callback. This prevents overlapping batch observations from corrupting a thread's scope.
+The observer implementation owns its tracing lifecycle.
+The generic semantic module has no OpenTelemetry dependency or SDK/exporter configuration.
+An OpenTelemetry integration should reuse Camel's configured telemetry infrastructure;
+trace sampling must not determine whether audit records are stored. This SPI supplies
+hooks and does not install an OpenTelemetry exporter or bind Camel to draft guardrail
+semantic-convention names.
+
+=== Browsing history
+
+Use `camel semantic audit my-app` to retrieve a table of retained records from the
+xref:manual::camel-jbang-managing.adoc#_semantic_audit_history[Camel CLI]. Add `--json` for
+machine-readable output, or `--event-id=EVENT_ID` to inspect a record and its linked evidence.
+The CLI uses the same reader, filters and cursors as the console and TUI.
+
+The read-only `semantic-audit` developer console accepts `eventId` for a selected record
+and its evidence, or a bounded page query with `limit` (1 to 200), `cursor`, `since` (UTC
+ISO-8601), `category`, `action`, `expert`, `routeId`, `namespace` and `correlationId`.
+Cursors belong to their backend and filter. Query responses report evictions, expired
+cursors, effective settings, delivery errors and dropped records. Backend error messages
+are replaced with a stable code. Querying does not evaluate a definition or require that
+an old definition still exists.
+
+The Semantic tab in xref:manual::camel-jbang-tui.adoc[Camel TUI] provides an Audit view
+with the same filters, table and linked-record inspector. `tui_get_audit` exposes this
+history through the TUI MCP server without changing the visible tab, filters, page or selection.
+Pass `eventId` alone to inspect a record and its evidence, or the console's filters, `limit` and returned
+`cursor` to query pages. TUI AI sessions load this tool only for integrations exposing the audit console,
+in both core and full tool modes. Screen navigation remains an explicit TUI action.
+`r` refreshes the current page and `g` returns to the latest page. Pending refreshes are coalesced,
+while the latest changed filter/page is queried after the active request finishes. `tui_get_table` also includes audit rows, filters,
+selected details, linked evidence and backend status when Audit is selected. The OpenTelemetry status
+recognizes both Camel OpenTelemetry tracer implementations, including subclasses. It reports the
+context tracer state; it does not claim that a semantic observer/exporter has been installed.
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/language/semantic/SemanticLanguage.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/language/semantic/SemanticLanguage.java
index 492de89daa3f..546e7d17e8f4 100644
--- a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/language/semantic/SemanticLanguage.java
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/language/semantic/SemanticLanguage.java
@@ -28,6 +28,7 @@ import java.util.IdentityHashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Properties;
 import java.util.Set;
 import java.util.TreeSet;
@@ -47,6 +48,7 @@ import org.apache.camel.semantic.SemanticEvaluation;
 import org.apache.camel.semantic.SemanticEvaluations;
 import org.apache.camel.semantic.SemanticExpert.ResultType;
 import org.apache.camel.semantic.SemanticResult;
+import org.apache.camel.semantic.internal.SemanticAuditService;
 import org.apache.camel.spi.FactoryFinder;
 import org.apache.camel.spi.Metadata;
 import org.apache.camel.spi.annotations.Language;
@@ -136,20 +138,41 @@ public class SemanticLanguage extends LanguageSupport {
      * declaration's state selector is not used. Contract, provider input and result validation still apply.
      */
     public SemanticResult evaluate(SemanticEvaluation evaluation, Object input) throws Exception {
-        ResolvedExpert resolved = expert("direct", evaluation);
-        Operation operation = resolved.capabilities.operation(evaluation.getOperation());
-        operation.validateInput(input);
-        resolved.provider.validateInput(evaluation, input);
-        if (Thread.currentThread().isInterrupted()) {
-            throw new InterruptedException("Semantic evaluation interrupted");
-        }
+        return evaluate(evaluation, input, null);
+    }
+
+    /** Internal console bridge carrying a request identity; applications use the two-argument evaluation method. */
+    public SemanticResult evaluate(SemanticEvaluation evaluation, Object input, SemanticAuditService.Request request)
+            throws Exception {
+        SemanticAuditService audit = SemanticAuditService.get(getCamelContext());
+        SemanticAuditService.Invocation invocation = null;
+        String reason = "invalid_declaration";
         try {
+            ResolvedExpert resolved = expert("direct", evaluation);
+            Operation operation = resolved.capabilities.operation(evaluation.getOperation());
+            invocation = audit.begin(null, null, evaluation, operation, resolved.reference, resolved.capabilities.getProvider(),
+                    null, request);
+            reason = "invalid_input";
+            operation.validateInput(input);
+            resolved.provider.validateInput(evaluation, input);
+            if (Thread.currentThread().isInterrupted()) {
+                throw new InterruptedException("Semantic evaluation interrupted");
+            }
+            reason = "provider_error";
             SemanticResult result = resolved.provider.evaluate(evaluation, input);
+            reason = "invalid_result";
             operation.validateResult(result);
+            invocation.complete("success", "evaluation_completed", result);
             return result;
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            throw e;
+        } catch (Exception | AssertionError failure) {
+            if (invocation == null) {
+                invocation = audit.begin(null, null, evaluation, null, auditExpert(evaluation), null, null, request);
+            }
+            invocation.complete("failed", failure instanceof InterruptedException ? "interrupted" : reason, null);
+            if (failure instanceof InterruptedException) {
+                Thread.currentThread().interrupt();
+            }
+            throw failure;
         }
     }
 
@@ -456,6 +479,24 @@ public class SemanticLanguage extends LanguageSupport {
         }
     }
 
+    private String auditExpert(SemanticEvaluation evaluation) {
+        if (evaluation == null) {
+            return null;
+        }
+        String reference = evaluation.getExpert();
+        if (reference == null) {
+            reference = defaultExpert;
+        }
+        if (reference == null) {
+            return selectedAdapterName;
+        }
+        try {
+            return getCamelContext().resolvePropertyPlaceholders(reference);
+        } catch (RuntimeException unresolved) {
+            return null;
+        }
+    }
+
     private static final class AdapterLock {
         private static final Object CREATION_LOCK = new Object();
         private final Object monitor = new Object();
@@ -632,6 +673,12 @@ public class SemanticLanguage extends LanguageSupport {
         }
 
         private Object evaluate(Exchange exchange, boolean asPredicate) {
+            SemanticAuditService audit = SemanticAuditService.get(getCamelContext());
+            Map<String, SemanticAuditService.Invocation> invocations = new LinkedHashMap<>();
+            List<SemanticAuditService.Invocation> active = new ArrayList<>();
+            String failureReason = "invalid_declaration";
+            Map<String, SemanticEvaluation> selected = Map.of();
+            exchange.removeProperty(SemanticAuditService.REFERENCES);
             exchange.removeProperty(RESULT);
             exchange.removeProperty(RESULTS);
             SemanticEvaluation single = null;
@@ -644,7 +691,7 @@ public class SemanticLanguage extends LanguageSupport {
             try {
                 Compiled current = compiled;
                 if (batch) {
-                    Map<String, SemanticEvaluation> selected = evaluations.get(names);
+                    selected = evaluations.get(names);
                     if (current == null || !current.evaluations.equals(selected)) {
                         current = compile(selected);
                     }
@@ -653,13 +700,25 @@ public class SemanticLanguage extends LanguageSupport {
                     if (single == null) {
                         single = evaluations.get(name);
                     }
+                    selected = Map.of(name, single);
                     if (current == null || current.evaluations.get(name) != single) {
-                        current = compile(Map.of(name, single));
+                        current = compile(selected);
                     }
                 }
                 if (asPredicate) {
                     requireBoolean(current.operations.get(names.get(0)));
                 }
+                String batchId = batch ? getCamelContext().getUuidGenerator().generateUuid() : null;
+                for (Group group : current.groups) {
+                    for (var entry : group.evaluations.entrySet()) {
+                        String reference = auditExpert(entry.getValue());
+                        invocations.put(entry.getKey(), audit.begin(exchange, entry.getKey(), entry.getValue(),
+                                current.operations.get(entry.getKey()), reference, group.expert.capabilities.getProvider(),
+                                batchId, null));
+                    }
+                }
+                active.addAll(invocations.values());
+                failureReason = "invalid_input";
                 Object state = current.state.evaluate(exchange, Object.class);
                 // A state selector can itself evaluate another semantic expression.
                 exchange.removeProperty(RESULT);
@@ -672,10 +731,13 @@ public class SemanticLanguage extends LanguageSupport {
                             "Unsupported state type for semantic evaluations: " + names
                                                        + ". Select strings, maps or lists explicitly");
                 }
+                setAuditReferences(exchange, invocations);
                 // Check every group's input before invoking any provider.
                 for (Group group : current.groups) {
                     try {
                         for (var entry : group.evaluations.entrySet()) {
+                            active.clear();
+                            active.add(invocations.get(entry.getKey()));
                             current.operations.get(entry.getKey()).validateInput(state);
                             group.expert.provider.validateInput(entry.getValue(), state);
                         }
@@ -686,6 +748,8 @@ public class SemanticLanguage extends LanguageSupport {
                                 invalid);
                     }
                 }
+                active.clear();
+                failureReason = "provider_error";
                 if (batch) {
                     Map<String, SemanticResult> results = new LinkedHashMap<>();
                     Map<String, Object> decisions = new LinkedHashMap<>();
@@ -693,14 +757,31 @@ public class SemanticLanguage extends LanguageSupport {
                         if (Thread.currentThread().isInterrupted()) {
                             throw new InterruptedException("Semantic batch evaluation interrupted");
                         }
+                        active.clear();
+                        group.evaluations.keySet().forEach(name -> active.add(invocations.get(name)));
+                        failureReason = "provider_error";
                         Map<String, SemanticResult> answers = group.expert.provider.evaluateBatch(group.evaluations, state);
+                        failureReason = "invalid_result";
                         if (answers == null || !answers.keySet().equals(group.evaluations.keySet())) {
                             throw new IllegalArgumentException("Semantic batch result names must match evaluation names");
                         }
+                        IllegalArgumentException invalidResult = null;
                         for (String name : group.evaluations.keySet()) {
-                            decisions.put(name,
-                                    validateResult(name, group.expert, current.operations.get(name), answers.get(name)));
+                            try {
+                                decisions.put(name,
+                                        validateResult(name, group.expert, current.operations.get(name), answers.get(name)));
+                                invocations.get(name).complete("success", "evaluation_completed", answers.get(name));
+                            } catch (IllegalArgumentException invalid) {
+                                invocations.get(name).complete("failed", "invalid_result", null);
+                                if (invalidResult == null) {
+                                    invalidResult = invalid;
+                                }
+                            }
                         }
+                        if (invalidResult != null) {
+                            throw invalidResult;
+                        }
+                        active.clear();
                         results.putAll(answers);
                     }
                     Map<String, SemanticResult> details = new LinkedHashMap<>();
@@ -713,20 +794,58 @@ public class SemanticLanguage extends LanguageSupport {
                     return Collections.unmodifiableMap(ordered);
                 }
                 SemanticEvaluation evaluation = current.evaluations.get(names.get(0));
+                active.add(invocations.get(names.get(0)));
                 SemanticResult result = current.groups.get(0).expert.provider.evaluate(evaluation, state);
+                failureReason = "invalid_result";
                 Object decision = validateResult(names.get(0), current.groups.get(0).expert,
                         current.operations.get(names.get(0)), result);
+                invocations.get(names.get(0)).complete("success", "evaluation_completed", result);
                 exchange.setProperty(RESULT, result);
                 return decision;
             } catch (InterruptedException e) {
+                finishFailed(invocations, active, "interrupted");
                 exchange.removeProperty(RESULT);
                 exchange.removeProperty(RESULTS);
                 Thread.currentThread().interrupt();
                 throw RuntimeCamelException.wrapRuntimeCamelException(e);
-            } catch (Exception e) {
+            } catch (Exception | AssertionError e) {
+                if (invocations.isEmpty()) {
+                    for (String name : names) {
+                        SemanticEvaluation declaration = selected.get(name);
+                        SemanticAuditService.Invocation rejected = audit.begin(exchange, name, declaration, null,
+                                auditExpert(declaration), null, null, null);
+                        invocations.put(name, rejected);
+                        rejected.complete("failed", failureReason, null);
+                    }
+                }
+                finishFailed(invocations, active, failureReason);
                 exchange.removeProperty(RESULT);
                 exchange.removeProperty(RESULTS);
+                if (e instanceof AssertionError error) {
+                    throw error;
+                }
                 throw RuntimeCamelException.wrapRuntimeCamelException(e);
+            } finally {
+                setAuditReferences(exchange, invocations);
+            }
+        }
+
+        private void setAuditReferences(Exchange exchange, Map<String, SemanticAuditService.Invocation> invocations) {
+            List<String> references = invocations.values().stream()
+                    .map(SemanticAuditService.Invocation::getEventId).filter(Objects::nonNull).toList();
+            if (references.isEmpty()) {
+                exchange.removeProperty(SemanticAuditService.REFERENCES);
+            } else {
+                exchange.setProperty(SemanticAuditService.REFERENCES, references);
+            }
+        }
+
+        private void finishFailed(
+                Map<String, SemanticAuditService.Invocation> invocations, List<SemanticAuditService.Invocation> active,
+                String reason) {
+            for (SemanticAuditService.Invocation invocation : invocations.values()) {
+                invocation.complete(active.contains(invocation) ? "failed" : "not_executed",
+                        active.contains(invocation) ? reason : "evaluation_aborted", null);
             }
         }
 
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/LoggingSemanticAuditSink.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/LoggingSemanticAuditSink.java
new file mode 100644
index 000000000000..815cf3bd76e2
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/LoggingSemanticAuditSink.java
@@ -0,0 +1,32 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import org.apache.camel.support.service.ServiceSupport;
+import org.apache.camel.util.json.JsonObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/** Structured records through the application's logging configuration; no independent file or exporter. */
+public final class LoggingSemanticAuditSink extends ServiceSupport implements SemanticAuditSink {
+    private static final Logger LOG = LoggerFactory.getLogger("org.apache.camel.semantic.audit");
+
+    @Override
+    public void append(SemanticAuditRecord record) {
+        LOG.info("{}", new JsonObject(record.toMap()).toJson());
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/MemorySemanticAuditStore.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/MemorySemanticAuditStore.java
new file mode 100644
index 000000000000..1aa7b7fbb024
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/MemorySemanticAuditStore.java
@@ -0,0 +1,126 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+import org.apache.camel.support.service.ServiceSupport;
+
+/** Bounded recent history, lost when the context is destroyed. No persistent-storage guarantee. */
+public final class MemorySemanticAuditStore extends ServiceSupport implements SemanticAuditSink, SemanticAuditReader {
+    private final int capacity;
+    private final String epoch = UUID.randomUUID().toString();
+    private final Deque<Entry> records = new ArrayDeque<>();
+    private long sequence;
+    private long evicted;
+
+    public MemorySemanticAuditStore(int capacity) {
+        if (capacity < 1 || capacity > 100000) {
+            throw new IllegalArgumentException("Invalid audit capacity");
+        }
+        this.capacity = capacity;
+    }
+
+    @Override
+    public synchronized void append(SemanticAuditRecord record) {
+        if (records.size() == capacity) {
+            records.removeLast();
+            evicted++;
+        }
+        records.addFirst(new Entry(++sequence, record));
+    }
+
+    @Override
+    public synchronized Optional<SemanticAuditRecord> get(String eventId) {
+        return records.stream().map(Entry::record).filter(r -> r.getEventId().equals(eventId)).findFirst();
+    }
+
+    @Override
+    public synchronized Map<String, SemanticAuditRecord> getAll(List<String> eventIds) {
+        if (eventIds.size() > 100) {
+            throw new IllegalArgumentException("Too many audit evidence references");
+        }
+        var selected = new HashSet<>(eventIds);
+        Map<String, SemanticAuditRecord> found = new LinkedHashMap<>();
+        for (Entry entry : records) {
+            if (selected.remove(entry.record.getEventId())) {
+                found.put(entry.record.getEventId(), entry.record);
+            }
+        }
+        return Map.copyOf(found);
+    }
+
+    @Override
+    public SemanticAuditPage query(SemanticAuditQuery query) {
+        long before = Long.MAX_VALUE;
+        if (query.getCursor() != null) {
+            String[] parts = query.getCursor().split(":", -1);
+            if (parts.length != 3 || !epoch.equals(parts[0])
+                    || !query.fingerprint().equals(parts[2])) {
+                throw new IllegalArgumentException("Audit cursor does not match this store or query");
+            }
+            try {
+                before = Long.parseLong(parts[1]);
+            } catch (NumberFormatException e) {
+                throw new IllegalArgumentException("Invalid audit cursor", e);
+            }
+        }
+        List<Entry> snapshot;
+        long evictions;
+        synchronized (this) {
+            snapshot = List.copyOf(records);
+            evictions = evicted;
+        }
+        boolean expired
+                = before != Long.MAX_VALUE && !snapshot.isEmpty() && before <= snapshot.get(snapshot.size() - 1).sequence;
+        List<SemanticAuditRecord> page = new ArrayList<>();
+        long last = 0;
+        boolean more = false;
+        for (Entry entry : snapshot) {
+            if (entry.sequence < before && query.matches(entry.record)) {
+                if (page.size() == query.getLimit()) {
+                    more = true;
+                    break;
+                }
+                page.add(entry.record);
+                last = entry.sequence;
+            }
+        }
+        String next
+                = more ? epoch + ":" + last + ":" + query.fingerprint() : null;
+        return new SemanticAuditPage(page, next, evictions, expired);
+    }
+
+    public int getCapacity() {
+        return capacity;
+    }
+
+    public synchronized int size() {
+        return records.size();
+    }
+
+    private record Entry(long sequence, SemanticAuditRecord record) {
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAudit.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAudit.java
new file mode 100644
index 000000000000..a0e2f794d6e7
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAudit.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.util.List;
+import java.util.Map;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.Exchange;
+import org.apache.camel.semantic.internal.SemanticAuditService;
+
+/** Route-facing entry point for explicit application decisions. Evaluation lifecycle plumbing is internal. */
+public final class SemanticAudit {
+    /** Evidence IDs from the latest semantic expression; save them if a later decision needs earlier evaluations. */
+    public static final String REFERENCES = "CamelSemanticAuditReferences";
+    private final CamelContext context;
+
+    private SemanticAudit(CamelContext context) {
+        this.context = context;
+    }
+
+    public static SemanticAudit get(CamelContext context) {
+        return new SemanticAudit(context);
+    }
+
+    /** Record the action actually declared by the route, independently of any expert's result meaning. */
+    public void decision(Exchange exchange, Map<String, String> decision, List<String> evidence) {
+        SemanticAuditService.get(context).decision(exchange, decision, evidence);
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditConfiguration.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditConfiguration.java
new file mode 100644
index 000000000000..c9818d90c86d
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditConfiguration.java
@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/** Immutable, context-wide audit configuration declared by one semantic DSL resource. */
+public final class SemanticAuditConfiguration {
+    public static final SemanticAuditConfiguration DISABLED
+            = new SemanticAuditConfiguration(false, Map.of(), List.of("memory"), "memory", 1000, 1000);
+    private final boolean enabled;
+    private final Map<String, Boolean> experts;
+    private final List<String> sinks;
+    private final String reader;
+    private final int capacity;
+    private final int queueCapacity;
+
+    public SemanticAuditConfiguration(boolean enabled, Map<String, Boolean> experts, List<String> sinks,
+                                      String reader, int capacity, int queueCapacity) {
+        this.enabled = enabled;
+        this.experts = Map.copyOf(experts);
+        this.sinks = List.copyOf(sinks);
+        this.reader = Objects.requireNonNull(reader);
+        if (capacity < 1 || capacity > 100000 || queueCapacity < 1 || queueCapacity > 100000
+                || sinks.isEmpty() || sinks.stream().anyMatch(String::isBlank)
+                || sinks.stream().distinct().count() != sinks.size() || reader.isBlank()
+                || experts.keySet().stream().anyMatch(String::isBlank)) {
+            throw new IllegalArgumentException(
+                    "Invalid semantic audit configuration: require unique sinks, nonblank references and capacities between 1 and 100000");
+        }
+        if ("memory".equals(reader) && !sinks.contains("memory")) {
+            throw new IllegalArgumentException("Semantic audit reader 'memory' requires the 'memory' sink");
+        }
+        this.capacity = capacity;
+        this.queueCapacity = queueCapacity;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    /** Whether explicit decisions and the dispatcher are enabled, independently of individual evaluation filtering. */
+    public boolean isCapturing() {
+        return enabled || experts.containsValue(true);
+    }
+
+    public boolean isEnabled(String expert) {
+        return expert == null ? enabled : experts.getOrDefault(expert, enabled);
+    }
+
+    public Map<String, Boolean> getExperts() {
+        return experts;
+    }
+
+    public List<String> getSinks() {
+        return sinks;
+    }
+
+    public String getReader() {
+        return reader;
+    }
+
+    public int getCapacity() {
+        return capacity;
+    }
+
+    public int getQueueCapacity() {
+        return queueCapacity;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof SemanticAuditConfiguration c && enabled == c.enabled && experts.equals(c.experts)
+                && sinks.equals(c.sinks) && reader.equals(c.reader) && capacity == c.capacity
+                && queueCapacity == c.queueCapacity;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(enabled, experts, sinks, reader, capacity, queueCapacity);
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditConsole.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditConsole.java
new file mode 100644
index 000000000000..91c32a5b8adf
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditConsole.java
@@ -0,0 +1,125 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.camel.semantic.internal.SemanticAuditService;
+import org.apache.camel.spi.Metadata;
+import org.apache.camel.spi.annotations.DevConsole;
+import org.apache.camel.support.console.AbstractDevConsole;
+import org.apache.camel.util.json.JsonObject;
+
+/** Read-only history. Querying never invokes an expert or needs its current declaration. */
+@DevConsole(name = "semantic-audit", displayName = "Semantic Audit", description = "Browse retained semantic audit records")
+public class SemanticAuditConsole extends AbstractDevConsole {
+    @Metadata(label = "query", description = "Event ID to inspect with its linked evaluation records",
+              javaType = "java.lang.String")
+    public static final String EVENT_ID = "eventId";
+    @Metadata(label = "query", description = "Backend cursor for an older page", javaType = "java.lang.String")
+    public static final String CURSOR = "cursor";
+    @Metadata(label = "query", description = "Maximum records, between 1 and 200", javaType = "java.lang.Integer",
+              defaultValue = "50")
+    public static final String LIMIT = "limit";
+    @Metadata(label = "query", description = "UTC earliest timestamp in ISO-8601 format", javaType = "java.lang.String")
+    public static final String SINCE = "since";
+    @Metadata(label = "query", description = "Filter by category", javaType = "java.lang.String")
+    public static final String CATEGORY = "category";
+    @Metadata(label = "query", description = "Filter by explicit route action", javaType = "java.lang.String")
+    public static final String ACTION = "action";
+    @Metadata(label = "query", description = "Filter by expert bean reference", javaType = "java.lang.String")
+    public static final String EXPERT = "expert";
+    @Metadata(label = "query", description = "Filter by route", javaType = "java.lang.String")
+    public static final String ROUTE = "routeId";
+    @Metadata(label = "query", description = "Filter by application namespace", javaType = "java.lang.String")
+    public static final String NAMESPACE = "namespace";
+    @Metadata(label = "query", description = "Filter by application correlation ID", javaType = "java.lang.String")
+    public static final String CORRELATION = "correlationId";
+
+    public SemanticAuditConsole() {
+        super("camel", "semantic-audit", "Semantic Audit", "Browse retained semantic audit records");
+    }
+
+    @Override
+    public Object call(MediaType mediaType, Map<String, Object> options) {
+        // A slow reader must not serialize independent connector requests on the console lock.
+        return mediaType == MediaType.JSON ? doCallJson(options) : doCallText(options);
+    }
+
+    @Override
+    protected String doCallText(Map<String, Object> options) {
+        return doCallJson(options).toString();
+    }
+
+    @Override
+    protected JsonObject doCallJson(Map<String, Object> options) {
+        SemanticAuditService audit = SemanticAuditService.get(getCamelContext());
+        JsonObject response = new JsonObject();
+        response.put("audit", audit.status());
+        try {
+            SemanticAuditReader reader = audit.getReader();
+            String eventId = optionString(options, EVENT_ID);
+            if (eventId != null) {
+                if (eventId.length() > 256) {
+                    throw new IllegalArgumentException("Invalid event ID");
+                }
+                SemanticAuditRecord record = reader.get(eventId).orElse(null);
+                response.put("record", record == null ? null : record.toMap());
+                List<Map<String, Object>> evidence = new ArrayList<>();
+                if (record != null) {
+                    List<String> ids = record.getEvidence();
+                    Map<String, SemanticAuditRecord> linkedRecords = reader.getAll(ids);
+                    for (String id : ids) {
+                        SemanticAuditRecord linked = linkedRecords.get(id);
+                        evidence.add(linked == null ? Map.of("eventId", id, "unavailable", true) : linked.toMap());
+                    }
+                }
+                response.put("evidence", evidence);
+            } else {
+                Map<String, String> filters = new LinkedHashMap<>();
+                for (String key : List.of(CATEGORY, ACTION, EXPERT, ROUTE, NAMESPACE, CORRELATION)) {
+                    String value = optionString(options, key);
+                    if (value != null && !value.isBlank()) {
+                        filters.put(key, value);
+                    }
+                }
+                String since = optionString(options, SINCE);
+                Object requestedLimit = options.get(LIMIT);
+                long limit = requestedLimit == null ? 50 : Long.parseLong(requestedLimit.toString());
+                if (limit < 1 || limit > 200) {
+                    throw new IllegalArgumentException("Invalid audit page size");
+                }
+                SemanticAuditPage page = reader.query(new SemanticAuditQuery(
+                        filters,
+                        since == null || since.isBlank() ? null : Instant.parse(since), optionString(options, CURSOR),
+                        (int) limit));
+                response.put("records", page.getRecords().stream().map(SemanticAuditRecord::toMap).toList());
+                response.put("nextCursor", page.getNextCursor());
+                response.put("evicted", page.getEvicted());
+                response.put("cursorExpired", page.isCursorExpired());
+            }
+        } catch (Exception | AssertionError | LinkageError failure) {
+            // Backend messages may contain queries or credentials. Export only a stable failure code.
+            response.put("error", "audit_query_failed");
+        }
+        return response;
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditDecision.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditDecision.java
new file mode 100644
index 000000000000..643600ed0926
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditDecision.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.camel.Exchange;
+import org.apache.camel.Processor;
+
+/** Bean/processor for an explicit route action. Configure through normal Java, YAML or XML beans. */
+public final class SemanticAuditDecision implements Processor {
+    private Map<String, String> fields = new LinkedHashMap<>();
+    private String evidenceProperty = SemanticAudit.REFERENCES;
+
+    public Map<String, String> getFields() {
+        return fields;
+    }
+
+    public void setFields(Map<String, String> fields) {
+        this.fields = new LinkedHashMap<>(fields);
+    }
+
+    public String getEvidenceProperty() {
+        return evidenceProperty;
+    }
+
+    public void setEvidenceProperty(String evidenceProperty) {
+        this.evidenceProperty = evidenceProperty;
+    }
+
+    @Override
+    public void process(Exchange exchange) {
+        Object supplied = evidenceProperty == null ? null : exchange.getProperty(evidenceProperty);
+        if (supplied != null
+                && (!(supplied instanceof List<?> refs) || refs.stream().anyMatch(ref -> !(ref instanceof String)))) {
+            throw new IllegalArgumentException("Audit evidence property must contain a list of event IDs");
+        }
+        @SuppressWarnings("unchecked")
+        List<String> evidence = supplied == null ? List.of() : (List<String>) supplied;
+        SemanticAudit.get(exchange.getContext()).decision(exchange, new LinkedHashMap<>(fields), evidence);
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditPage.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditPage.java
new file mode 100644
index 000000000000..0337aa7a970d
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditPage.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.util.List;
+
+/** A newest-first page. Evictions and cursor expiration are visible instead of silently skipping history. */
+public final class SemanticAuditPage {
+    private final List<SemanticAuditRecord> records;
+    private final String nextCursor;
+    private final long evicted;
+    private final boolean cursorExpired;
+
+    public SemanticAuditPage(List<SemanticAuditRecord> records, String nextCursor, long evicted, boolean cursorExpired) {
+        this.records = List.copyOf(records);
+        this.nextCursor = nextCursor;
+        this.evicted = evicted;
+        this.cursorExpired = cursorExpired;
+    }
+
+    public List<SemanticAuditRecord> getRecords() {
+        return records;
+    }
+
+    public String getNextCursor() {
+        return nextCursor;
+    }
+
+    public long getEvicted() {
+        return evicted;
+    }
+
+    public boolean isCursorExpired() {
+        return cursorExpired;
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditQuery.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditQuery.java
new file mode 100644
index 000000000000..d9e04d460b4c
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditQuery.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.time.Instant;
+import java.util.HexFormat;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+/** Bounded query. Cursors are backend-specific and must not be reused with another filter. */
+public final class SemanticAuditQuery {
+    private static final Set<String> FIELDS = Set.of("category", "action", "expert", "routeId", "namespace", "correlationId");
+    private final Map<String, String> filters;
+    private final Instant since;
+    private final String cursor;
+    private final int limit;
+
+    public SemanticAuditQuery(Map<String, String> filters, Instant since, String cursor, int limit) {
+        if (limit < 1 || limit > 200 || !FIELDS.containsAll(filters.keySet())
+                || filters.values().stream().anyMatch(v -> v == null || v.length() > 256)
+                || cursor != null && cursor.length() > 512) {
+            throw new IllegalArgumentException("Invalid semantic audit query");
+        }
+        this.filters = Map.copyOf(filters);
+        this.since = since;
+        this.cursor = cursor;
+        this.limit = limit;
+    }
+
+    public Map<String, String> getFilters() {
+        return filters;
+    }
+
+    public Instant getSince() {
+        return since;
+    }
+
+    public String getCursor() {
+        return cursor;
+    }
+
+    String fingerprint() {
+        StringBuilder canonical = new StringBuilder(since == null ? "" : since.toString()).append(';');
+        new TreeMap<>(filters).forEach((key, value) -> canonical.append(key.length()).append(':').append(key)
+                .append(value.length()).append(':').append(value));
+        try {
+            return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256")
+                    .digest(canonical.toString().getBytes(StandardCharsets.UTF_8)));
+        } catch (NoSuchAlgorithmException impossible) {
+            throw new IllegalStateException(impossible);
+        }
+    }
+
+    public int getLimit() {
+        return limit;
+    }
+
+    /** Exact, case-sensitive AND of the filters and an inclusive lower bound on event time. */
+    public boolean matches(SemanticAuditRecord record) {
+        return (since == null || !record.getTimestamp().isBefore(since))
+                && filters.entrySet().stream().allMatch(e -> e.getValue().equals(record.text(e.getKey())));
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditReader.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditReader.java
new file mode 100644
index 000000000000..ef42a2f059a0
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditReader.java
@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/** Read-only browsing, independent of the destination's append capability. */
+public interface SemanticAuditReader {
+    SemanticAuditPage query(SemanticAuditQuery query) throws Exception;
+
+    Optional<SemanticAuditRecord> get(String eventId) throws Exception;
+
+    /**
+     * Resolve up to 100 linked event IDs. Missing records are absent; remote backends should override with one query.
+     */
+    default Map<String, SemanticAuditRecord> getAll(List<String> eventIds) throws Exception {
+        if (eventIds.size() > 100) {
+            throw new IllegalArgumentException("Too many audit evidence references");
+        }
+        Map<String, SemanticAuditRecord> records = new LinkedHashMap<>();
+        for (String id : eventIds) {
+            if (!records.containsKey(id)) {
+                get(id).ifPresent(record -> records.put(id, record));
+            }
+        }
+        return Map.copyOf(records);
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditRecord.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditRecord.java
new file mode 100644
index 000000000000..9cd7aeb71950
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditRecord.java
@@ -0,0 +1,195 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.time.Instant;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Immutable, size-bounded snapshot. It never contains the exchange, input or provider exception. Schema version 1 uses
+ * UTC timestamps and keeps route actions separate from expert results.
+ */
+public final class SemanticAuditRecord {
+    private final Map<String, Object> fields;
+    private final Instant timestamp;
+
+    SemanticAuditRecord(Map<String, Object> fields) {
+        this.fields = Collections.unmodifiableMap(new LinkedHashMap<>(fields));
+        this.timestamp = Instant.parse((String) fields.get("timestamp"));
+    }
+
+    /** Reconstruct a persisted version-1 record; rejects unknown fields and bounds nested data. */
+    public static SemanticAuditRecord fromMap(Map<String, ?> data) {
+        Set<String> keys = Set.of("schemaVersion", "eventId", "invocationId", "timestamp", "category", "origin", "requestId",
+                "batchId", "definition", "target", "expert", "operation", "contextId", "exchangeId", "routeId", "semantics",
+                "status", "reasonCode", "durationNanos", "resultOmitted", "result", "action", "namespace", "correlationId",
+                "policyId", "policyVersion", "rule", "evidence", "startedAt", "provider", "model", "revision");
+        if (!keys.containsAll(data.keySet()) || !(data.get("schemaVersion") instanceof Number version)
+                || version.doubleValue() != 1
+                || !(data.get("eventId") instanceof String id) || id.isBlank() || id.length() > 256
+                || !(data.get("category") instanceof String category)
+                || !Set.of("evaluation", "decision", "request").contains(category)
+                || !(data.get("timestamp") instanceof String timestamp)) {
+            throw new IllegalArgumentException("Invalid semantic audit record");
+        }
+        Set<String> structured = Set.of("schemaVersion", "durationNanos", "semantics", "result", "evidence");
+        data.forEach((key, value) -> {
+            if (!structured.contains(key) && !(value instanceof String)) {
+                throw new IllegalArgumentException("Invalid audit text field: " + key);
+            }
+        });
+        if (data.containsKey("durationNanos") && (!(data.get("durationNanos") instanceof Number duration)
+                || duration.longValue() < 0 || duration.doubleValue() != duration.longValue())) {
+            throw new IllegalArgumentException("Invalid audit duration");
+        }
+        if (data.containsKey("startedAt")) {
+            if (!(data.get("startedAt") instanceof String startedAt)) {
+                throw new IllegalArgumentException("Invalid audit start timestamp");
+            }
+            Instant.parse(startedAt);
+        }
+        for (String key : List.of("provider", "model", "revision")) {
+            if (data.containsKey(key) && (!(data.get(key) instanceof String text) || text.isBlank())) {
+                throw new IllegalArgumentException("Invalid audit producer identity");
+            }
+        }
+        if (data.containsKey("evidence") && (!(data.get("evidence") instanceof List<?> ids)
+                || ids.size() > 100 || ids.stream().anyMatch(reference -> !(reference instanceof String text)
+                        || text.isBlank() || text.length() > 256))) {
+            throw new IllegalArgumentException("Invalid audit evidence references");
+        }
+        validateKeys(data.get("semantics"), Set.of("resultType", "meaning", "probabilityMeaning", "confidenceMeaning"));
+        validateKeys(data.get("result"), Set.of("value", "probability", "confidence", "probabilities"));
+        if (data.get("semantics") instanceof Map<?, ?> semantics
+                && semantics.values().stream().anyMatch(value -> !(value instanceof String))) {
+            throw new IllegalArgumentException("Invalid audit semantics");
+        }
+        if (data.get("result") instanceof Map<?, ?> result) {
+            Object value = result.get("value");
+            if (value != null && !(value instanceof Boolean || value instanceof Number || value instanceof String
+                    || value instanceof List<?> labels && labels.stream().allMatch(String.class::isInstance))) {
+                throw new IllegalArgumentException("Invalid audit result value");
+            }
+            for (String key : List.of("probability", "confidence")) {
+                if (result.containsKey(key)) {
+                    validateProbability(result.get(key));
+                }
+            }
+            if (result.containsKey("probabilities")) {
+                if (!(result.get("probabilities") instanceof Map<?, ?> probabilities)) {
+                    throw new IllegalArgumentException("Invalid audit probabilities");
+                }
+                probabilities.values().forEach(SemanticAuditRecord::validateProbability);
+            }
+        }
+        Map<String, Object> copy = new LinkedHashMap<>();
+        data.forEach((key, value) -> copy.put(key, freeze(value, 0)));
+        return new SemanticAuditRecord(copy);
+    }
+
+    private static void validateProbability(Object value) {
+        if (!(value instanceof Number number) || !Double.isFinite(number.doubleValue())
+                || number.doubleValue() < 0 || number.doubleValue() > 1) {
+            throw new IllegalArgumentException("Invalid audit probability or confidence");
+        }
+    }
+
+    /** Completion/event occurrence time, parsed once when this immutable record is created. */
+    public Instant getTimestamp() {
+        return timestamp;
+    }
+
+    public Instant getStartedAt() {
+        String started = text("startedAt");
+        return started == null ? null : Instant.parse(started);
+    }
+
+    public Long getDurationNanos() {
+        return fields.get("durationNanos") instanceof Number duration ? duration.longValue() : null;
+    }
+
+    public List<String> getEvidence() {
+        return fields.get("evidence") instanceof List<?> ids ? ids.stream().map(String.class::cast).toList() : List.of();
+    }
+
+    private static void validateKeys(Object value, Set<String> allowed) {
+        if (value != null && (!(value instanceof Map<?, ?> map) || !allowed.containsAll(map.keySet()))) {
+            throw new IllegalArgumentException("Invalid audit snapshot fields");
+        }
+    }
+
+    private static Object freeze(Object value, int depth) {
+        if (value instanceof String text) {
+            if (text.codePointCount(0, text.length()) > 256 || text.codePoints().anyMatch(Character::isISOControl)) {
+                throw new IllegalArgumentException("Invalid audit text");
+            }
+            return text;
+        }
+        if (value instanceof Boolean || value instanceof Integer || value instanceof Long) {
+            return value;
+        }
+        if (value instanceof Number number && Double.isFinite(number.doubleValue())) {
+            return number.doubleValue();
+        }
+        if (depth < 2 && value instanceof List<?> list && list.size() <= 100) {
+            return list.stream().map(item -> freeze(item, depth + 1)).toList();
+        }
+        if (depth < 2 && value instanceof Map<?, ?> map && map.size() <= 100) {
+            Map<String, Object> copy = new LinkedHashMap<>();
+            map.forEach((key, item) -> {
+                if (!(key instanceof String text)) {
+                    throw new IllegalArgumentException("Invalid audit key");
+                }
+                copy.put((String) freeze(text, depth + 1), freeze(item, depth + 1));
+            });
+            return Collections.unmodifiableMap(copy);
+        }
+        throw new IllegalArgumentException("Invalid audit value");
+    }
+
+    public String getEventId() {
+        return text("eventId");
+    }
+
+    public String getInvocationId() {
+        return text("invocationId");
+    }
+
+    public String getCategory() {
+        return text("category");
+    }
+
+    public String getExpert() {
+        return text("expert");
+    }
+
+    public String getStatus() {
+        return text("status");
+    }
+
+    public String text(String name) {
+        return fields.get(name) instanceof String value ? value : null;
+    }
+
+    public Map<String, Object> toMap() {
+        return fields;
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditSink.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditSink.java
new file mode 100644
index 000000000000..484090e055ef
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticAuditSink.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import org.apache.camel.Service;
+
+/**
+ * Pluggable destination for safe records. Calls are serialized per audit dispatcher. Returning means the destination
+ * accepted the record, not that it is durably committed. A destination must document its own durability, bound its I/O
+ * and honor interruption. The dispatcher does not retry failed appends; backend retries must preserve the event ID.
+ */
+public interface SemanticAuditSink extends Service {
+    void append(SemanticAuditRecord record) throws Exception;
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluateConsole.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluateConsole.java
index 5f305998a818..2fd847162069 100644
--- a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluateConsole.java
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluateConsole.java
@@ -26,6 +26,7 @@ import java.util.concurrent.TimeoutException;
 import org.apache.camel.Expression;
 import org.apache.camel.builder.ThreadPoolBuilder;
 import org.apache.camel.language.semantic.SemanticLanguage;
+import org.apache.camel.semantic.internal.SemanticAuditService;
 import org.apache.camel.spi.Metadata;
 import org.apache.camel.spi.annotations.DevConsole;
 import org.apache.camel.support.DefaultExchange;
@@ -120,18 +121,23 @@ public class SemanticEvaluateConsole extends AbstractDevConsole {
     protected Map<String, Object> doCallJson(Map<String, Object> options) {
         long start = System.nanoTime();
         Future<Map<String, Object>> task = null;
+        SemanticAuditService audit = SemanticAuditService.get(getCamelContext());
+        SemanticAuditService.Request request
+                = audit.request(options.containsKey(OPERATION) ? "direct_sample" : "definition_sample");
         String failure;
         try {
             long timeout = optionLong(options, TIMEOUT, 50000);
             if (timeout < 1 || timeout > 50000) {
                 throw new IllegalArgumentException("Evaluation timeout must be between 1 and 50000 milliseconds");
             }
-            task = executor().submit(() -> evaluate(options));
+            task = executor().submit(() -> evaluate(options, request));
             return task.get(timeout, TimeUnit.MILLISECONDS);
         } catch (TimeoutException e) {
+            audit.requestOutcome(request, "timeout_cancellation_requested");
             failure = "Evaluation timed out; cancellation requested";
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
+            audit.requestOutcome(request, "cancellation_requested");
             failure = "Evaluation cancelled";
         } catch (RejectedExecutionException e) {
             failure = "Busy: semantic evaluations are already running";
@@ -146,7 +152,7 @@ public class SemanticEvaluateConsole extends AbstractDevConsole {
                 optionString(options, EVALUATION), "failed", null, null, null, null, null, elapsed(start), failure));
     }
 
-    private Map<String, Object> evaluate(Map<String, Object> options) {
+    private Map<String, Object> evaluate(Map<String, Object> options, SemanticAuditService.Request request) {
         String name = optionString(options, EVALUATION);
         long start = System.nanoTime();
         try {
@@ -164,7 +170,7 @@ public class SemanticEvaluateConsole extends AbstractDevConsole {
                 SemanticEvaluation evaluation = new SemanticEvaluation(
                         optionString(options, OPERATION), optionString(options, EXPERT), null, parameters);
                 SemanticLanguage language = (SemanticLanguage) getCamelContext().resolveLanguage("semantic");
-                SemanticResult result = language.evaluate(evaluation, options.get(INPUT));
+                SemanticResult result = language.evaluate(evaluation, options.get(INPUT), request);
                 return response(null, result, start);
             }
             if (options.containsKey(EXPERT) || options.containsKey(INPUT) || options.containsKey(PARAMETERS)) {
@@ -175,6 +181,7 @@ public class SemanticEvaluateConsole extends AbstractDevConsole {
             }
             SemanticEvaluations.get(getCamelContext()).get(name);
             var exchange = new DefaultExchange(getCamelContext());
+            exchange.setProperty(SemanticAuditService.REQUEST, request);
             exchange.getMessage().setBody(options.get(BODY));
             if (options.get(HEADERS) instanceof Map<?, ?> headers) {
                 headers.forEach((key, value) -> exchange.getMessage().setHeader(key.toString(), value));
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluations.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluations.java
index 8c3c8bfa2215..8311e19b5f78 100644
--- a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluations.java
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluations.java
@@ -27,6 +27,7 @@ import java.util.function.Consumer;
 
 import org.apache.camel.CamelContext;
 import org.apache.camel.language.semantic.SemanticLanguage;
+import org.apache.camel.semantic.internal.SemanticAuditService;
 import org.apache.camel.spi.Resource;
 
 /** Context-local named evaluations, replaced atomically per source when a route resource is reloaded. */
@@ -90,6 +91,21 @@ public final class SemanticEvaluations {
      * source.
      */
     public synchronized void replace(String source, Map<String, SemanticEvaluation> definitions) {
+        replace(source, definitions, null);
+    }
+
+    private synchronized void replace(
+            String source, Map<String, SemanticEvaluation> definitions, SemanticAuditConfiguration audit) {
+        replace(source, definitions, audit, false);
+    }
+
+    private void replace(
+            String source, Map<String, SemanticEvaluation> definitions,
+            SemanticAuditConfiguration audit, boolean deleted) {
+        SemanticAuditService recorder = SemanticAuditService.get(context);
+        if (!deleted) {
+            recorder.validateConfiguration(source, audit);
+        }
         Map<String, SemanticEvaluation> replacement = new HashMap<>();
         sources.forEach((location, entries) -> {
             if (!location.equals(source)) {
@@ -126,6 +142,11 @@ public final class SemanticEvaluations {
             sources.put(source, Map.copyOf(definitions));
         }
         resources.remove(source);
+        if (deleted) {
+            recorder.removeConfigurationSource(source);
+        } else {
+            recorder.configure(source, audit);
+        }
         evaluations = snapshot;
     }
 
@@ -135,20 +156,30 @@ public final class SemanticEvaluations {
     }
 
     synchronized void replace(String location, Resource source, Map<String, SemanticEvaluation> definitions) {
+        replace(location, source, definitions, null);
+    }
+
+    public synchronized void replace(
+            Resource source, Map<String, SemanticEvaluation> definitions, SemanticAuditConfiguration audit) {
+        replace(source.getLocation(), source, definitions, audit);
+    }
+
+    synchronized void replace(
+            String location, Resource source, Map<String, SemanticEvaluation> definitions, SemanticAuditConfiguration audit) {
         removeDeletedResources();
-        replace(location, definitions);
-        if (source != null && !definitions.isEmpty() && "file".equals(source.getScheme())) {
+        replace(location, definitions, audit);
+        if (source != null && (!definitions.isEmpty() || audit != null) && "file".equals(source.getScheme())) {
             resources.put(location, source);
         }
     }
 
     synchronized void removeDeletedResources() {
         resources.entrySet().stream().filter(entry -> !entry.getValue().exists()).map(Map.Entry::getKey).toList()
-                .forEach(location -> replace(location, Map.of()));
+                .forEach(location -> replace(location, Map.of(), null, true));
     }
 
     synchronized void remove(String source) {
-        if (sources.containsKey(source)) {
+        if (sources.containsKey(source) || resources.containsKey(source)) {
             replace(source, Map.of());
         }
     }
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluationsBuilder.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluationsBuilder.java
index f6168f8ccb20..ef21a159f708 100644
--- a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluationsBuilder.java
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticEvaluationsBuilder.java
@@ -30,6 +30,7 @@ import org.apache.camel.spi.Resource;
 /** Fluent declarations for use inside an ordinary {@link RouteBuilder#configure()}. */
 public final class SemanticEvaluationsBuilder {
     private static final String LIFECYCLE = SemanticEvaluationsBuilder.class.getName();
+    private SemanticAuditConfiguration audit;
     private String expert;
     private String state;
     private final CamelContext context;
@@ -57,6 +58,12 @@ public final class SemanticEvaluationsBuilder {
         return new SemanticEvaluationsBuilder(builder);
     }
 
+    /** Context-wide auditing; declare in exactly one source. Changes require a context restart. */
+    public SemanticEvaluationsBuilder audit(SemanticAuditConfiguration audit) {
+        this.audit = audit;
+        return this;
+    }
+
     public SemanticEvaluationsBuilder expert(String expert) {
         this.expert = expert;
         return this;
@@ -101,7 +108,7 @@ public final class SemanticEvaluationsBuilder {
         });
         SemanticEvaluations registry = SemanticEvaluations.get(context);
         synchronized (registry) {
-            registry.replace(source, resource, definitions);
+            registry.replace(source, resource, definitions, audit);
             DeclarationsLifecycle lifecycle = context.getRegistry().lookupByNameAndType(LIFECYCLE, DeclarationsLifecycle.class);
             if (lifecycle == null) {
                 lifecycle = new DeclarationsLifecycle(registry);
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticObserver.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticObserver.java
new file mode 100644
index 000000000000..7cb44265eb07
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticObserver.java
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+/**
+ * Independent semantic lifecycle consumer, for telemetry or application observations. Registered observers run on the
+ * invocation thread and must not block. Callbacks must restore any thread context before returning; an observation is
+ * not an attached tracing scope. Batch members can overlap, so each span uses the supplied parent explicitly and
+ * remains detached between callbacks. This also avoids putting unrelated batch members in a span tree. No OpenTelemetry
+ * or provider classes are part of this contract. Audit filtering and trace sampling do not govern each other. All
+ * callbacks receive the same bounded safe snapshots. Register beans before context startup: observers are discovered
+ * once when the audit service starts, independently of whether audit capture is enabled.
+ */
+public interface SemanticObserver {
+    /**
+     * Capture an implementation-specific parent context before an executor handoff. Never put it in an audit record.
+     */
+    default Object captureContext() {
+        return null;
+    }
+
+    /** Start a detached invocation observation using the supplied parent context. */
+    Observation started(SemanticAuditRecord record, Object parentContext);
+
+    default void decision(SemanticAuditRecord record) {
+    }
+
+    interface Observation {
+        /** Finish on the invocation thread, including on failure. Restore temporary context before returning. */
+        void completed(SemanticAuditRecord record);
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticReloadPlugin.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticReloadPlugin.java
index de0f7cd71750..af6ef498752d 100644
--- a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticReloadPlugin.java
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticReloadPlugin.java
@@ -18,6 +18,7 @@ package org.apache.camel.semantic;
 
 import org.apache.camel.CamelContext;
 import org.apache.camel.RuntimeCamelException;
+import org.apache.camel.semantic.internal.SemanticAuditService;
 import org.apache.camel.spi.ContextServicePlugin;
 import org.apache.camel.spi.LifecycleStrategy;
 import org.apache.camel.spi.RoutesBuilderLoader;
@@ -35,6 +36,7 @@ public class SemanticReloadPlugin implements ContextServicePlugin {
         lifecycle = new LifecycleStrategySupport() {
             @Override
             public void onContextStarting(CamelContext camelContext) {
+                SemanticAuditService.get(camelContext).activate();
                 SemanticEvaluations evaluations
                         = camelContext.getCamelContextExtension().getContextPlugin(SemanticEvaluations.class);
                 if (evaluations != null) {
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticXmlRoutesBuilderLoader.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticXmlRoutesBuilderLoader.java
index d6553ac0804d..14d2015f5dda 100644
--- a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticXmlRoutesBuilderLoader.java
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/SemanticXmlRoutesBuilderLoader.java
@@ -56,7 +56,12 @@ public class SemanticXmlRoutesBuilderLoader extends RoutesBuilderLoaderSupport {
     @Override
     public RoutesBuilder loadRoutesBuilder(Resource resource) throws Exception {
         // Resource-set bean preparation is complete; declarations still precede every route configuration.
-        RoutesDefinition routes = parse(resource);
+        RoutesDefinition routes;
+        try {
+            routes = parse(resource);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Invalid semantic XML in " + resource.getLocation() + ": " + e.getMessage(), e);
+        }
         RouteBuilder builder = new RouteBuilder(getCamelContext()) {
             @Override
             public void configure() {
@@ -147,7 +152,16 @@ public class SemanticXmlRoutesBuilderLoader extends RoutesBuilderLoaderSupport {
         if (semantic.hasAttribute("state")) {
             evaluations.state(semantic.getAttribute("state"));
         }
+        boolean auditSeen = false;
         for (Element element : children(semantic)) {
+            if ("audit".equals(element.getLocalName())) {
+                if (auditSeen) {
+                    throw new IllegalArgumentException("Only one audit declaration is allowed");
+                }
+                auditSeen = true;
+                evaluations.audit(audit(element));
+                continue;
+            }
             if (!"evaluation".equals(element.getLocalName())) {
                 throw new IllegalArgumentException("Unexpected semantic element: " + element.getTagName());
             }
@@ -164,6 +178,61 @@ public class SemanticXmlRoutesBuilderLoader extends RoutesBuilderLoaderSupport {
         }
     }
 
+    private SemanticAuditConfiguration audit(Element element) {
+        attributes(element, Set.of("enabled", "reader", "capacity", "queueCapacity"));
+        Map<String, Boolean> experts = new LinkedHashMap<>();
+        List<String> sinks = new ArrayList<>();
+        for (Element child : children(element)) {
+            if ("expert".equals(child.getLocalName())) {
+                attributes(child, Set.of("name", "enabled"));
+                String name = child.getAttribute("name");
+                if (!child.hasAttribute("enabled")) {
+                    throw new IllegalArgumentException("Audit expert '" + name + "' requires enabled");
+                }
+                if (experts.putIfAbsent(name, auditBoolean(child.getAttribute("enabled"))) != null) {
+                    throw new IllegalArgumentException("Duplicate audit expert: " + name);
+                }
+            } else if ("sink".equals(child.getLocalName())) {
+                attributes(child, Set.of("ref"));
+                sinks.add(getCamelContext().resolvePropertyPlaceholders(child.getAttribute("ref")));
+            } else {
+                throw new IllegalArgumentException("Unexpected semantic audit element: " + child.getTagName());
+            }
+            if (!children(child).isEmpty()) {
+                throw new IllegalArgumentException("Unexpected nested audit element");
+            }
+        }
+        return new SemanticAuditConfiguration(
+                element.hasAttribute("enabled") && auditBoolean(element.getAttribute("enabled")),
+                experts, sinks.isEmpty() ? List.of("memory") : sinks,
+                auditAttribute(element, "reader", "memory"), auditCapacity(element, "capacity"),
+                auditCapacity(element, "queueCapacity"));
+    }
+
+    private int auditCapacity(Element element, String key) {
+        try {
+            int value = Integer.parseInt(auditAttribute(element, key, "1000"));
+            if (value >= 1 && value <= 100000) {
+                return value;
+            }
+        } catch (NumberFormatException ignored) {
+            // Include the option name and resource instead of a bare numeric parse error.
+        }
+        throw new IllegalArgumentException("Semantic audit '" + key + "' requires an integer between 1 and 100000");
+    }
+
+    private String auditAttribute(Element element, String key, String fallback) {
+        return element.hasAttribute(key) ? getCamelContext().resolvePropertyPlaceholders(element.getAttribute(key)) : fallback;
+    }
+
+    private boolean auditBoolean(String text) {
+        String value = getCamelContext().resolvePropertyPlaceholders(text);
+        if (!"true".equals(value) && !"false".equals(value)) {
+            throw new IllegalArgumentException("Audit enabled must be true or false");
+        }
+        return Boolean.parseBoolean(value);
+    }
+
     private void evaluation(Element element, SemanticEvaluationsBuilder evaluations) {
         attributes(element,
                 Set.of("name", "type", "operation", "expert", "state", "threshold", "uncertainty", "uncertaintyPolicy"));
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/internal/SemanticAuditService.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/internal/SemanticAuditService.java
new file mode 100644
index 000000000000..cf0577690468
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/internal/SemanticAuditService.java
@@ -0,0 +1,540 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic.internal;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.Exchange;
+import org.apache.camel.RuntimeCamelException;
+import org.apache.camel.builder.ThreadPoolBuilder;
+import org.apache.camel.semantic.LoggingSemanticAuditSink;
+import org.apache.camel.semantic.MemorySemanticAuditStore;
+import org.apache.camel.semantic.SemanticAuditConfiguration;
+import org.apache.camel.semantic.SemanticAuditReader;
+import org.apache.camel.semantic.SemanticAuditRecord;
+import org.apache.camel.semantic.SemanticAuditSink;
+import org.apache.camel.semantic.SemanticCapabilities;
+import org.apache.camel.semantic.SemanticEvaluation;
+import org.apache.camel.semantic.SemanticObserver;
+import org.apache.camel.semantic.SemanticResult;
+import org.apache.camel.support.service.ServiceHelper;
+import org.apache.camel.support.service.ServiceSupport;
+import org.apache.camel.util.concurrent.ThreadPoolRejectedPolicy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/** Internal context-owned dispatcher. This lifecycle plumbing is not a supported application or backend API. */
+public final class SemanticAuditService extends ServiceSupport {
+    public static final String REFERENCES = "CamelSemanticAuditReferences";
+    public static final String REQUEST = "CamelSemanticAuditRequest";
+    private static final Logger LOG = LoggerFactory.getLogger(SemanticAuditService.class);
+    private static final Object CREATION_LOCK = new Object();
+    private final CamelContext context;
+    private volatile SemanticAuditConfiguration configuration = SemanticAuditConfiguration.DISABLED;
+    private String configurationSource;
+    private final AtomicLong dropped = new AtomicLong();
+    private final AtomicLong observerErrors = new AtomicLong();
+    private final Map<String, AtomicLong> sinkErrors = new LinkedHashMap<>();
+    private final Map<String, SemanticAuditSink> sinks = new LinkedHashMap<>();
+    private volatile List<SemanticObserver> observers = List.of();
+    private volatile ExecutorService executor;
+    private MemorySemanticAuditStore memory;
+    private volatile SemanticAuditReader reader;
+    private volatile boolean activated;
+    private boolean frozen;
+    private final Invocation noop = new Invocation(null, false);
+
+    private SemanticAuditService(CamelContext context) {
+        this.context = context;
+    }
+
+    public static SemanticAuditService get(CamelContext context) {
+        var extension = context.getCamelContextExtension();
+        SemanticAuditService audit = extension.getContextPlugin(SemanticAuditService.class);
+        if (audit == null) {
+            synchronized (CREATION_LOCK) {
+                audit = extension.getContextPlugin(SemanticAuditService.class);
+                if (audit == null) {
+                    audit = new SemanticAuditService(context);
+                    extension.addContextPlugin(SemanticAuditService.class, audit);
+                }
+            }
+        }
+        return audit;
+    }
+
+    public synchronized void validateConfiguration(String source, SemanticAuditConfiguration candidate) {
+        if (configurationSource != null && !configurationSource.equals(source) && candidate != null) {
+            throw new IllegalArgumentException("Declare semantic audit configuration in only one resource");
+        }
+        if (candidate == null && !source.equals(configurationSource)) {
+            return;
+        }
+        SemanticAuditConfiguration next = candidate == null ? SemanticAuditConfiguration.DISABLED : candidate;
+        if (frozen && !configuration.equals(next)) {
+            throw new IllegalArgumentException("Changing semantic audit configuration requires a context restart");
+        }
+    }
+
+    public synchronized void configure(String source, SemanticAuditConfiguration candidate) {
+        validateConfiguration(source, candidate);
+        if (candidate != null || source.equals(configurationSource)) {
+            configuration = candidate == null ? SemanticAuditConfiguration.DISABLED : candidate;
+            configurationSource = candidate == null ? null : source;
+        }
+    }
+
+    public synchronized void removeConfigurationSource(String source) {
+        if (source.equals(configurationSource)) {
+            configurationSource = null;
+            if (frozen) {
+                LOG.warn("Semantic audit resource {} was deleted; retaining the active configuration until context restart",
+                        source);
+            } else {
+                configuration = SemanticAuditConfiguration.DISABLED;
+            }
+        }
+    }
+
+    public void activate() {
+        if (!activated) {
+            synchronized (this) {
+                if (!activated) {
+                    try {
+                        context.addService(this, true, true);
+                        activated = true;
+                    } catch (Exception e) {
+                        throw RuntimeCamelException.wrapRuntimeCamelException(e);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    protected void doStart() throws Exception {
+        synchronized (this) {
+            frozen = true;
+        }
+        observers = List.copyOf(context.getRegistry().findByType(SemanticObserver.class));
+        if (memory == null || memory.getCapacity() != configuration.getCapacity()) {
+            memory = new MemorySemanticAuditStore(configuration.getCapacity());
+        }
+        sinkErrors.clear();
+        for (String name : configuration.getSinks()) {
+            SemanticAuditSink sink = switch (name) {
+                case "memory" -> memory;
+                case "log" -> new LoggingSemanticAuditSink();
+                default -> context.getRegistry().lookupByNameAndType(name, SemanticAuditSink.class);
+            };
+            if (sink == null) {
+                throw new IllegalArgumentException("Unknown semantic audit sink: " + name);
+            }
+            sinks.put(name, sink);
+            sinkErrors.putIfAbsent(name, new AtomicLong());
+        }
+        reader = "memory".equals(configuration.getReader())
+                ? memory
+                : context.getRegistry().lookupByNameAndType(configuration.getReader(), SemanticAuditReader.class);
+        if (reader == null) {
+            throw new IllegalArgumentException("Unknown semantic audit reader: " + configuration.getReader());
+        }
+        boolean capturing = configuration.isCapturing();
+        if (!capturing) {
+            return;
+        }
+        try {
+            for (SemanticAuditSink sink : sinks.values()) {
+                ServiceHelper.startService(sink);
+            }
+            ServiceHelper.startService(reader);
+            executor = new ThreadPoolBuilder(context).poolSize(1).maxPoolSize(1)
+                    .maxQueueSize(configuration.getQueueCapacity()).rejectedPolicy(ThreadPoolRejectedPolicy.Abort)
+                    .build(this, "SemanticAuditService");
+        } catch (Exception e) {
+            ServiceHelper.stopService(sinks.values());
+            ServiceHelper.stopService(reader);
+            throw e;
+        }
+    }
+
+    @Override
+    protected void doStop() throws Exception {
+        ExecutorService current = executor;
+        executor = null;
+        if (current != null) {
+            current.shutdown();
+            try {
+                if (!current.awaitTermination(5, TimeUnit.SECONDS)) {
+                    dropped.addAndGet(current.shutdownNow().size());
+                }
+            } catch (InterruptedException e) {
+                dropped.addAndGet(current.shutdownNow().size());
+                Thread.currentThread().interrupt();
+            } finally {
+                context.getExecutorServiceManager().shutdownNow(current);
+            }
+        }
+        try {
+            ServiceHelper.stopService(sinks.values());
+            ServiceHelper.stopService(reader);
+        } finally {
+            synchronized (this) {
+                sinks.clear();
+                frozen = false;
+                if (configurationSource == null) {
+                    configuration = SemanticAuditConfiguration.DISABLED;
+                }
+            }
+        }
+    }
+
+    public synchronized SemanticAuditConfiguration getConfiguration() {
+        return configuration;
+    }
+
+    public SemanticAuditReader getReader() {
+        activate();
+        if (isStarted()) {
+            try {
+                ServiceHelper.startService(reader);
+            } catch (Exception failure) {
+                throw RuntimeCamelException.wrapRuntimeCamelException(failure);
+            }
+        }
+        return reader;
+    }
+
+    public synchronized Map<String, Object> status() {
+        Map<String, Object> status = new LinkedHashMap<>();
+        status.put("enabled", configuration.isEnabled());
+        status.put("decisionsEnabled", configuration.isCapturing());
+        status.put("experts", configuration.getExperts());
+        status.put("reader", configuration.getReader());
+        status.put("sinks", configuration.getSinks());
+        status.put("capacity", configuration.getCapacity());
+        status.put("retained", memory == null ? 0 : memory.size());
+        status.put("dropped", dropped.get());
+        status.put("observerErrors", observerErrors.get());
+        Map<String, Long> errors = new LinkedHashMap<>();
+        sinkErrors.forEach((name, count) -> errors.put(name, count.get()));
+        status.put("sinkErrors", errors);
+        status.put("state", getStatus().name());
+        status.put("observerCount", observers.size());
+        status.put("openTelemetry",
+                ServiceHelper.isStarted(context.hasService(
+                        service -> isOpenTelemetryTracer(service.getClass()) && ServiceHelper.isStarted(service)))
+                                ? "active" : "inactive");
+        return status;
+    }
+
+    private static boolean isOpenTelemetryTracer(Class<?> type) {
+        for (Class<?> current = type; current != null; current = current.getSuperclass()) {
+            if (current.getName().equals("org.apache.camel.opentelemetry2.OpenTelemetryTracer")
+                    || current.getName().equals("org.apache.camel.opentelemetry.OpenTelemetryTracer")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /** Capture parent observation contexts on the caller thread before dispatching a console request. */
+    public Request request(String origin) {
+        activate();
+        Map<SemanticObserver, Object> parents = new IdentityHashMap<>();
+        for (SemanticObserver observer : observers) {
+            try {
+                parents.put(observer, observer.captureContext());
+            } catch (Exception | AssertionError | LinkageError failure) {
+                observerErrors.incrementAndGet();
+            }
+        }
+        return new Request(origin, parents);
+    }
+
+    /** A request identity is shared by cancellation observations and eventual provider completion. */
+    public static final class Request {
+        private final String id = UUID.randomUUID().toString();
+        private final String origin;
+        private final Map<SemanticObserver, Object> parents;
+        private final AtomicBoolean claimed = new AtomicBoolean();
+        private volatile boolean audited;
+
+        private Request(String origin, Map<SemanticObserver, Object> parents) {
+            this.origin = origin;
+            this.parents = parents;
+        }
+    }
+
+    public Invocation begin(
+            Exchange exchange, String name, SemanticEvaluation evaluation,
+            SemanticCapabilities.Operation operation, String expert, String provider, String batchId, Request request) {
+        activate();
+        if (request == null && exchange != null) {
+            request = exchange.getProperty(REQUEST, Request.class);
+        }
+        boolean first = request != null && request.claimed.compareAndSet(false, true);
+        boolean enabled = expert != null && configuration.isEnabled(expert);
+        if (request != null && enabled) {
+            request.audited = true;
+        }
+        if (!enabled && observers.isEmpty()) {
+            return noop;
+        }
+        Map<String, Object> fields = new LinkedHashMap<>();
+        fields.put("schemaVersion", 1);
+        fields.put("eventId", UUID.randomUUID().toString());
+        fields.put("invocationId", first ? request.id : UUID.randomUUID().toString());
+        fields.put("timestamp", Instant.now().toString());
+        fields.put("startedAt", fields.get("timestamp"));
+        fields.put("category", "evaluation");
+        put(fields, "provider", provider);
+        fields.put("origin", request == null ? exchange == null ? "direct" : "route" : request.origin);
+        put(fields, "requestId", request == null ? null : request.id);
+        put(fields, "batchId", batchId);
+        put(fields, "definition", name);
+        put(fields, "target", name);
+        put(fields, "expert", expert);
+        put(fields, "operation", evaluation == null ? null : evaluation.getOperation());
+        put(fields, "contextId", context.getName());
+        if (exchange != null) {
+            put(fields, "exchangeId", exchange.getExchangeId());
+            put(fields, "routeId", exchange.getFromRouteId());
+        }
+        if (operation != null) {
+            Map<String, Object> semantics = new LinkedHashMap<>();
+            put(semantics, "resultType", operation.getResultType().name());
+            put(semantics, "meaning", operation.getResultMeaning());
+            put(semantics, "probabilityMeaning", operation.getProbabilityMeaning());
+            put(semantics, "confidenceMeaning", operation.getConfidenceMeaning());
+            // Caller-authored score descriptions and arbitrary parameters are deliberately omitted.
+            fields.put("semantics", Map.copyOf(semantics));
+        }
+        Invocation invocation = new Invocation(fields, enabled);
+        SemanticAuditRecord started = SemanticAuditRecord.fromMap(fields);
+        for (SemanticObserver observer : observers) {
+            try {
+                Object parent = request == null ? observer.captureContext() : request.parents.get(observer);
+                SemanticObserver.Observation handle = observer.started(started, parent);
+                if (handle != null) {
+                    invocation.handles.add(handle);
+                }
+            } catch (Exception | AssertionError | LinkageError failure) {
+                observerErrors.incrementAndGet();
+            }
+        }
+        return invocation;
+    }
+
+    public final class Invocation {
+        private final Map<String, Object> fields;
+        private final boolean enabled;
+        private final long start = System.nanoTime();
+        private final List<SemanticObserver.Observation> handles = new ArrayList<>();
+        // Confined to the invocation thread; cancellation emits a separate request record.
+        private boolean completed;
+
+        private Invocation(Map<String, Object> fields, boolean enabled) {
+            this.fields = fields;
+            this.enabled = enabled;
+        }
+
+        public String getEventId() {
+            return fields == null ? null : (String) fields.get("eventId");
+        }
+
+        public void complete(String status, String reason, SemanticResult result) {
+            if (fields == null || completed) {
+                return;
+            }
+            completed = true;
+            fields.put("status", status);
+            fields.put("reasonCode", reason);
+            fields.put("durationNanos", Math.max(0, System.nanoTime() - start));
+            fields.put("timestamp", Instant.now().toString());
+            if (result != null) {
+                for (String key : List.of("model", "revision")) {
+                    Object value = result.getMetadata().get(key);
+                    if (value instanceof String text && !text.isBlank() && text.equals(safe(text))) {
+                        fields.put(key, text);
+                    }
+                }
+                Map<String, Object> captured = snapshot(result);
+                if (captured == null) {
+                    fields.put("resultOmitted", "snapshot_limit");
+                } else {
+                    fields.put("result", captured);
+                }
+            }
+            SemanticAuditRecord record = SemanticAuditRecord.fromMap(fields);
+            // Notify observers in reverse start-callback order; no ambient scope spans callbacks.
+            for (int i = handles.size() - 1; i >= 0; i--) {
+                try {
+                    handles.get(i).completed(record);
+                } catch (Exception | AssertionError | LinkageError failure) {
+                    observerErrors.incrementAndGet();
+                }
+            }
+            if (enabled) {
+                publish(record);
+            }
+        }
+    }
+
+    public void requestOutcome(Request request, String reason) {
+        // An unresolved request has no effective expert setting yet; do not bypass exclusions.
+        if (!request.audited) {
+            return;
+        }
+        Map<String, Object> fields = base("request");
+        put(fields, "requestId", request.id);
+        put(fields, "invocationId", request.id);
+        put(fields, "origin", request.origin);
+        put(fields, "status", reason);
+        put(fields, "reasonCode", reason);
+        publish(SemanticAuditRecord.fromMap(fields));
+    }
+
+    /**
+     * Record an explicit application decision. Capture is active if the global default or any expert enables auditing.
+     */
+    public void decision(Exchange exchange, Map<String, String> decision, List<String> evidence) {
+        activate();
+        Set<String> allowed = Set.of("action", "operation", "target", "namespace", "reasonCode", "correlationId", "policyId",
+                "policyVersion", "rule");
+        if (!allowed.containsAll(decision.keySet()) || decision.get("action") == null || decision.get("action").isBlank()
+                || evidence.size() > 100
+                || evidence.stream().anyMatch(id -> id == null || id.isBlank() || id.length() > 256 || !id.equals(safe(id)))) {
+            throw new IllegalArgumentException("Invalid semantic audit decision or evidence references");
+        }
+        Map<String, Object> fields = base("decision");
+        decision.forEach((key, value) -> put(fields, key, value));
+        fields.put("evidence", List.copyOf(evidence));
+        if (exchange != null) {
+            put(fields, "exchangeId", exchange.getExchangeId());
+            put(fields, "routeId", exchange.getFromRouteId());
+        }
+        SemanticAuditRecord record = SemanticAuditRecord.fromMap(fields);
+        for (SemanticObserver observer : observers) {
+            try {
+                observer.decision(record);
+            } catch (Exception | AssertionError | LinkageError failure) {
+                observerErrors.incrementAndGet();
+            }
+        }
+        if (configuration.isCapturing()) {
+            publish(record);
+        }
+    }
+
+    private Map<String, Object> base(String category) {
+        Map<String, Object> fields = new LinkedHashMap<>();
+        fields.put("schemaVersion", 1);
+        fields.put("eventId", UUID.randomUUID().toString());
+        fields.put("timestamp", Instant.now().toString());
+        fields.put("category", category);
+        put(fields, "contextId", context.getName());
+        return fields;
+    }
+
+    private void publish(SemanticAuditRecord record) {
+        ExecutorService current = executor;
+        if (current == null || !isStarted()) {
+            dropped.incrementAndGet();
+            return;
+        }
+        try {
+            current.execute(() -> {
+                for (var entry : sinks.entrySet()) {
+                    try {
+                        entry.getValue().append(record);
+                    } catch (Exception | AssertionError | LinkageError failure) {
+                        sinkErrors.get(entry.getKey()).incrementAndGet();
+                    }
+                }
+            });
+        } catch (RejectedExecutionException full) {
+            dropped.incrementAndGet();
+        }
+    }
+
+    private static Map<String, Object> snapshot(SemanticResult result) {
+        Map<String, Object> values = new LinkedHashMap<>();
+        Object value = result.getValue();
+        if (value instanceof String text && !text.equals(safe(text))
+                || value instanceof Set<?> labels && (labels.size() > 100
+                        || labels.stream().anyMatch(label -> !(label instanceof String text) || !text.equals(safe(text))))
+                || result.getProbabilities().size() > 100
+                || result.getProbabilities().keySet().stream().anyMatch(key -> !key.equals(safe(key)))) {
+            return null;
+        }
+        if (value instanceof Boolean) {
+            values.put("value", value);
+        } else if (value instanceof Number number && Double.isFinite(number.doubleValue())) {
+            values.put("value", number.doubleValue());
+        } else if (value instanceof String text) {
+            put(values, "value", text);
+        } else if (value instanceof Set<?> labels) {
+            values.put("value", labels.stream().filter(String.class::isInstance).map(String.class::cast).limit(100)
+                    .map(SemanticAuditService::safe).toList());
+        }
+        if (result.getProbability() != null) {
+            values.put("probability", result.getProbability());
+        }
+        if (result.getConfidence() != null) {
+            values.put("confidence", result.getConfidence());
+        }
+        Map<String, Double> probabilities = new LinkedHashMap<>();
+        result.getProbabilities().entrySet().stream().limit(100)
+                .forEach(e -> probabilities.put(safe(e.getKey()), e.getValue()));
+        if (!probabilities.isEmpty()) {
+            values.put("probabilities", Map.copyOf(probabilities));
+        }
+        // Arbitrary provider metadata is not safe to export merely because it is named 'metadata'.
+        return Collections.unmodifiableMap(values);
+    }
+
+    private static void put(Map<String, Object> fields, String key, String value) {
+        if (value != null && !value.isBlank()) {
+            fields.put(key, safe(value));
+        }
+    }
+
+    private static String safe(String value) {
+        StringBuilder text = new StringBuilder();
+        value.codePoints().filter(cp -> !Character.isISOControl(cp)).limit(257).forEach(text::appendCodePoint);
+        if (text.codePointCount(0, text.length()) > 256) {
+            text.setLength(text.offsetByCodePoints(0, 255));
+            text.append('…');
+        }
+        return text.toString();
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/yaml/SemanticDefinitionDeserializer.java b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/yaml/SemanticDefinitionDeserializer.java
index c54bd48f6224..d09e5be2b555 100644
--- a/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/yaml/SemanticDefinitionDeserializer.java
+++ b/components/camel-ai/camel-semantic/src/main/java/org/apache/camel/semantic/yaml/SemanticDefinitionDeserializer.java
@@ -30,6 +30,7 @@ import org.apache.camel.dsl.yaml.common.YamlDeserializerResolver;
 import org.apache.camel.dsl.yaml.common.YamlDeserializerSupport;
 import org.apache.camel.dsl.yaml.common.exception.InvalidNodeTypeException;
 import org.apache.camel.dsl.yaml.common.exception.YamlDeserializationException;
+import org.apache.camel.semantic.SemanticAuditConfiguration;
 import org.apache.camel.semantic.SemanticEvaluation;
 import org.apache.camel.semantic.SemanticEvaluationBuilder;
 import org.apache.camel.semantic.SemanticEvaluations;
@@ -49,11 +50,15 @@ import org.snakeyaml.engine.v2.nodes.Tag;
 /** Named semantic declarations are installed in a resource-wide pass before route references are resolved. */
 @YamlIn
 @YamlType(nodes = "semantic", properties = {
-        @YamlProperty(name = "expert", type = "string"),
-        @YamlProperty(name = "state", type = "string"),
-        @YamlProperty(name = "evaluation",
-                      type = "map:org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$EvaluationSchema",
-                      required = true)
+        @YamlProperty(name = "__oneOf",
+                      type = "object:org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$EvaluationDeclarationSchema",
+                      oneOf = "declaration", required = true),
+        @YamlProperty(name = "__oneOf",
+                      type = "object:org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditDeclarationSchema",
+                      oneOf = "declaration", required = true),
+        @YamlProperty(name = "__oneOf",
+                      type = "object:org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditedEvaluationDeclarationSchema",
+                      oneOf = "declaration", required = true)
 })
 public class SemanticDefinitionDeserializer extends YamlDeserializerSupport implements ConstructNode, YamlDeserializerResolver {
     private static final Tag NUMBER = new Tag("!number");
@@ -80,6 +85,7 @@ public class SemanticDefinitionDeserializer extends YamlDeserializerSupport impl
             return;
         }
         Map<String, SemanticEvaluation> definitions = new LinkedHashMap<>();
+        SemanticAuditConfiguration audit = null;
         for (Node node : sequence.getValue()) {
             if (!(node instanceof MappingNode mapping)) {
                 // Leave malformed entries to the route loader without replacing the resource's evaluations.
@@ -87,7 +93,15 @@ public class SemanticDefinitionDeserializer extends YamlDeserializerSupport impl
             }
             for (NodeTuple tuple : mapping.getValue()) {
                 if ("semantic".equals(asText(tuple.getKeyNode()))) {
-                    read(dc.getCamelContext(), tuple.getValueNode()).forEach((name, evaluation) -> {
+                    Declaration declaration = read(dc.getCamelContext(), tuple.getValueNode());
+                    if (declaration.audit != null) {
+                        if (audit != null) {
+                            throw new YamlDeserializationException(
+                                    tuple.getValueNode(), "Only one audit declaration is allowed");
+                        }
+                        audit = declaration.audit;
+                    }
+                    declaration.definitions.forEach((name, evaluation) -> {
                         if (definitions.putIfAbsent(name, evaluation) != null) {
                             throw new YamlDeserializationException(
                                     tuple.getValueNode(), "Duplicate semantic evaluation: " + name);
@@ -97,55 +111,162 @@ public class SemanticDefinitionDeserializer extends YamlDeserializerSupport impl
             }
         }
         CamelContext context = dc.getCamelContext();
-        SemanticEvaluations evaluations = definitions.isEmpty()
+        SemanticEvaluations evaluations = definitions.isEmpty() && audit == null
                 ? context.getCamelContextExtension().getContextPlugin(SemanticEvaluations.class)
                 : SemanticEvaluations.get(context);
         if (evaluations != null) {
             try {
-                evaluations.replace(dc.getResource(), definitions);
+                evaluations.replace(dc.getResource(), definitions, audit);
             } catch (IllegalArgumentException e) {
                 throw new YamlDeserializationException(root, e.getMessage(), e);
             }
         }
     }
 
-    private static Map<String, SemanticEvaluation> read(CamelContext context, Node node) {
+    private static Declaration read(CamelContext context, Node node) {
         Map<String, Node> semantic = fields(node, "semantic declaration");
         for (String field : semantic.keySet()) {
-            if (!Set.of("evaluation", "expert", "state").contains(field)) {
+            if (!Set.of("evaluation", "expert", "state", "audit").contains(field)) {
                 throw new YamlDeserializationException(
                         semantic.get(field), "Unknown property '" + field + "' in semantic declaration");
             }
         }
-        if (!semantic.containsKey("evaluation")) {
-            throw new YamlDeserializationException(node, "Semantic declaration requires evaluation");
+        if (!semantic.containsKey("evaluation") && !semantic.containsKey("audit")) {
+            throw new YamlDeserializationException(node, "Semantic declaration requires evaluation or audit");
         }
         Map<String, SemanticEvaluation> result = new LinkedHashMap<>();
-        fields(semantic.get("evaluation"), "semantic evaluations").forEach((name, definition) -> {
-            if (name.isBlank()) {
-                throw new YamlDeserializationException(definition, "Semantic evaluation requires a nonblank name");
-            }
-            Map<String, Node> values = fields(definition, "semantic evaluation '" + name + "'");
-            for (String common : List.of("expert", "state")) {
-                if (!values.containsKey(common) && semantic.containsKey(common)) {
-                    values.put(common, semantic.get(common));
+        if (semantic.containsKey("evaluation")) {
+            fields(semantic.get("evaluation"), "semantic evaluations").forEach((name, definition) -> {
+                if (name.isBlank()) {
+                    throw new YamlDeserializationException(definition, "Semantic evaluation requires a nonblank name");
                 }
-            }
-            String expert = "default/automatic";
-            try {
-                if (values.containsKey("expert")) {
-                    expert = "invalid expert reference";
-                    expert = asText(values.get("expert"));
+                Map<String, Node> values = fields(definition, "semantic evaluation '" + name + "'");
+                for (String common : List.of("expert", "state")) {
+                    if (!values.containsKey(common) && semantic.containsKey(common)) {
+                        values.put(common, semantic.get(common));
+                    }
                 }
-                result.put(name, readEvaluation(context, name, expert, definition, values));
-            } catch (IllegalArgumentException | InvalidNodeTypeException e) {
-                throw new YamlDeserializationException(
-                        definition, "Invalid semantic evaluation '" + name + "': " + e.getMessage()
-                                    + " (expert '" + expert + "')",
-                        e);
+                String expert = "default/automatic";
+                try {
+                    if (values.containsKey("expert")) {
+                        expert = "invalid expert reference";
+                        expert = asText(values.get("expert"));
+                    }
+                    result.put(name, readEvaluation(context, name, expert, definition, values));
+                } catch (IllegalArgumentException | InvalidNodeTypeException e) {
+                    throw new YamlDeserializationException(
+                            definition, "Invalid semantic evaluation '" + name + "': " + e.getMessage()
+                                        + " (expert '" + expert + "')",
+                            e);
+                }
+            });
+        }
+        return new Declaration(result, semantic.containsKey("audit") ? audit(context, semantic.get("audit")) : null);
+    }
+
+    private record Declaration(Map<String, SemanticEvaluation> definitions, SemanticAuditConfiguration audit) {
+    }
+
+    private static SemanticAuditConfiguration audit(CamelContext context, Node node) {
+        try {
+            return readAudit(context, node);
+        } catch (IllegalArgumentException e) {
+            throw new YamlDeserializationException(node, "Invalid semantic audit configuration: " + e.getMessage(), e);
+        }
+    }
+
+    private static SemanticAuditConfiguration readAudit(CamelContext context, Node node) {
+        Map<String, Node> values = fields(node, "semantic audit");
+        if (!Set.of("enabled", "experts", "sinks", "reader", "capacity", "queueCapacity").containsAll(values.keySet())) {
+            throw new YamlDeserializationException(node, "Unknown semantic audit option");
+        }
+        Map<String, Boolean> experts = new LinkedHashMap<>();
+        if (values.containsKey("experts")) {
+            fields(values.get("experts"), "audit experts").forEach((name, expert) -> {
+                Map<String, Node> settings = fields(expert, "audit expert");
+                if (!settings.keySet().equals(Set.of("enabled"))) {
+                    throw new YamlDeserializationException(expert, "Audit expert requires only enabled");
+                }
+                experts.put(name, auditBoolean(context, settings.get("enabled")));
+            });
+        }
+        List<String> sinks = values.containsKey("sinks")
+                ? asSequenceNode(values.get("sinks")).getValue().stream()
+                        .map(n -> context.resolvePropertyPlaceholders(asText(n))).toList()
+                : List.of("memory");
+        return new SemanticAuditConfiguration(
+                values.containsKey("enabled") && auditBoolean(context, values.get("enabled")),
+                experts, sinks, auditText(context, values, "reader", "memory"),
+                auditCapacity(context, values, "capacity"), auditCapacity(context, values, "queueCapacity"));
+    }
+
+    private static int auditCapacity(CamelContext context, Map<String, Node> values, String key) {
+        Node node = values.get(key);
+        if (node == null) {
+            return 1000;
+        }
+        try {
+            int value = Integer.parseInt(context.resolvePropertyPlaceholders(asText(node)));
+            if (value >= 1 && value <= 100000) {
+                return value;
             }
-        });
-        return result;
+        } catch (NumberFormatException ignored) {
+            // Report the same bound and source location for malformed and out-of-range values.
+        }
+        throw new YamlDeserializationException(node, "Audit '" + key + "' requires an integer between 1 and 100000");
+    }
+
+    private static boolean auditBoolean(CamelContext context, Node node) {
+        String value = context.resolvePropertyPlaceholders(asText(node));
+        if (!"true".equals(value) && !"false".equals(value)) {
+            throw new YamlDeserializationException(node, "Audit enabled must be true or false");
+        }
+        return Boolean.parseBoolean(value);
+    }
+
+    private static String auditText(CamelContext context, Map<String, Node> values, String name, String fallback) {
+        return values.containsKey(name) ? context.resolvePropertyPlaceholders(asText(values.get(name))) : fallback;
+    }
+
+    @YamlType(properties = {
+            @YamlProperty(name = "expert", type = "string"),
+            @YamlProperty(name = "state", type = "string")
+    })
+    public static class DeclarationSchema {
+    }
+
+    @YamlType(properties = @YamlProperty(name = "evaluation",
+                                         type = "map:org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$EvaluationSchema",
+                                         required = true))
+    public static class EvaluationDeclarationSchema extends DeclarationSchema {
+    }
+
+    @YamlType(properties = @YamlProperty(name = "audit",
+                                         type = "object:org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditSchema",
+                                         required = true))
+    public static class AuditDeclarationSchema extends DeclarationSchema {
+    }
+
+    @YamlType(properties = @YamlProperty(name = "audit",
+                                         type = "object:org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditSchema",
+                                         required = true))
+    public static class AuditedEvaluationDeclarationSchema extends EvaluationDeclarationSchema {
+    }
+
+    @YamlType(properties = {
+            @YamlProperty(name = "enabled", type = "boolean"),
+            @YamlProperty(name = "experts",
+                          type = "map:org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditExpertSchema"),
+            @YamlProperty(name = "sinks", type = "array:string"),
+            @YamlProperty(name = "reader", type = "string"),
+            @YamlProperty(name = "capacity", type = "integer"),
+            @YamlProperty(name = "queueCapacity", type = "integer")
+    })
+    public static class AuditSchema {
+    }
+
+    @YamlType(properties = { @YamlProperty(name = "enabled", type = "boolean", required = true) })
+    public static class AuditExpertSchema {
     }
 
     private static SemanticEvaluation readEvaluation(
diff --git a/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditConsoleTest.java b/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditConsoleTest.java
new file mode 100644
index 000000000000..a0de98849287
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditConsoleTest.java
@@ -0,0 +1,236 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.camel.console.DevConsole;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.camel.semantic.internal.SemanticAuditService;
+import org.apache.camel.util.json.JsonObject;
+import org.apache.camel.util.json.Jsoner;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Property;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class SemanticAuditConsoleTest {
+    private static final String TIME = "2026-10-09T12:00:00Z";
+
+    @Test
+    void rejectsAnUnfedMemoryReaderButAllowsIndependentBackends() {
+        assertThatThrownBy(() -> new SemanticAuditConfiguration(true, Map.of(), List.of("log"), "memory", 10, 10))
+                .hasMessageContaining("reader 'memory' requires the 'memory' sink");
+        assertThat(new SemanticAuditConfiguration(true, Map.of(), List.of("log"), "database", 10, 10).getReader())
+                .isEqualTo("database");
+    }
+
+    @Test
+    void consoleFiltersSinceInclusivelyAndPagesThroughRetainedRecords() throws Exception {
+        try (var fixture = new Fixture()) {
+            var filters = Map.of("category", "decision", "action", "block", "expert", "security", "routeId", "route1",
+                    "namespace", "tenant1", "correlationId", "request1");
+            fixture.store.append(record("old", Map.of("timestamp", "2026-10-09T11:00:00Z")));
+            fixture.store.append(record("matching", filters));
+            fixture.store.append(record("newest", Map.of("timestamp", "2026-10-09T13:00:00Z")));
+            Map<String, Object> options = new HashMap<>(filters);
+            options.put("since", TIME);
+            var filtered = fixture.call(options);
+            assertThat(rows(filtered)).extracting(r -> r.get("eventId")).containsExactly("matching");
+            for (String field : filters.keySet()) {
+                assertThat(rows(fixture.call(Map.of(field, "missing")))).isEmpty();
+            }
+            assertThat(rows(fixture.call(Map.of("since", TIME))))
+                    .extracting(r -> r.get("eventId")).containsExactly("newest", "matching");
+            var page = fixture.call(Map.of("limit", 1));
+            assertThat(rows(page)).extracting(r -> r.get("eventId")).containsExactly("newest");
+            assertThat(rows(fixture.call(Map.of("cursor", page.get("nextCursor"), "limit", 1))))
+                    .extracting(r -> r.get("eventId")).containsExactly("matching");
+        }
+    }
+
+    @Test
+    void consoleUsesBulkEvidenceLookupAndPreservesMissingRecords() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            var evaluation = record("evaluation", Map.of("category", "evaluation"));
+            var decision = record("decision", Map.of("evidence", List.of("evaluation", "missing")));
+            AtomicInteger gets = new AtomicInteger();
+            AtomicInteger bulkGets = new AtomicInteger();
+            context.getRegistry().bind("remote", new SemanticAuditReader() {
+                public SemanticAuditPage query(SemanticAuditQuery query) {
+                    throw new AssertionError("unexpected query");
+                }
+
+                public Optional<SemanticAuditRecord> get(String id) {
+                    gets.incrementAndGet();
+                    assertThat(id).isEqualTo("decision");
+                    return Optional.of(decision);
+                }
+
+                public Map<String, SemanticAuditRecord> getAll(List<String> ids) {
+                    bulkGets.incrementAndGet();
+                    assertThat(ids).containsExactly("evaluation", "missing");
+                    return Map.of("evaluation", evaluation);
+                }
+            });
+            SemanticAuditService.get(context).configure("test",
+                    new SemanticAuditConfiguration(false, Map.of(), List.of("memory"), "remote", 10, 10));
+            context.start();
+            var console = new SemanticAuditConsole();
+            console.setCamelContext(context);
+            var result = (JsonObject) console.call(DevConsole.MediaType.JSON, Map.of("eventId", "decision"));
+            assertThat(result.get("evidence"))
+                    .isEqualTo(List.of(evaluation.toMap(), Map.of("eventId", "missing", "unavailable", true)));
+            assertThat(gets).hasValue(1);
+            assertThat(bulkGets).hasValue(1);
+            console.stop();
+        }
+    }
+
+    @Test
+    void consoleReportsAnUnavailableSelectedEvent() throws Exception {
+        try (var fixture = new Fixture()) {
+            assertThat(fixture.call(Map.of("eventId", "absent"))).containsEntry("record", null).containsEntry("evidence",
+                    List.of());
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "0", "201", "-1", "abc" })
+    void consoleRejectsInvalidPageLimitsWithoutLeakingInput(String limit) throws Exception {
+        try (var fixture = new Fixture()) {
+            assertThat(fixture.call(Map.of("limit", limit))).containsEntry("error", "audit_query_failed")
+                    .doesNotContainKey("records");
+        }
+    }
+
+    @Test
+    void consoleSanitizesInvalidQueriesAndBackendFailures() throws Exception {
+        try (var fixture = new Fixture()) {
+            for (String field : List.of("since", "cursor")) {
+                var result = fixture.call(Map.of(field, "private-invalid-value"));
+                assertThat(result).containsEntry("error", "audit_query_failed");
+                assertThat(result.toJson()).doesNotContain("private-invalid-value");
+            }
+        }
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("broken", new SemanticAuditReader() {
+                public SemanticAuditPage query(SemanticAuditQuery query) {
+                    throw new IllegalStateException("secret credentials");
+                }
+
+                public Optional<SemanticAuditRecord> get(String id) {
+                    throw new IllegalStateException("secret credentials");
+                }
+            });
+            SemanticAuditService.get(context).configure("test",
+                    new SemanticAuditConfiguration(false, Map.of(), List.of("memory"), "broken", 10, 10));
+            context.start();
+            var console = new SemanticAuditConsole();
+            console.setCamelContext(context);
+            for (Map<String, Object> options : List.of(Map.<String, Object> of(), Map.<String, Object> of("eventId", "a"))) {
+                var result = (JsonObject) console.call(DevConsole.MediaType.JSON, options);
+                assertThat(result).containsEntry("error", "audit_query_failed");
+                assertThat(result.toJson()).doesNotContain("secret", "credentials");
+            }
+            console.stop();
+        }
+    }
+
+    @Test
+    void persistedEvidenceMustBeAListOfBoundedNonblankStringIds() {
+        for (Object evidence : List.of(List.of(42), List.of(""), List.of(" "), List.of("x".repeat(257)), List.of("bad\n"),
+                "event-id")) {
+            assertThatThrownBy(() -> record("decision", Map.of("evidence", evidence)))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    void loggingSinkWritesTheStructuredRecordAsJson() throws Exception {
+        Logger logger = (Logger) LogManager.getLogger("org.apache.camel.semantic.audit");
+        Level previous = logger.getLevel();
+        List<String> messages = new ArrayList<>();
+        var appender = new AbstractAppender("SemanticAuditTest", null, null, true, Property.EMPTY_ARRAY) {
+            public void append(LogEvent event) {
+                messages.add(event.getMessage().getFormattedMessage());
+            }
+        };
+        appender.start();
+        logger.addAppender(appender);
+        logger.setLevel(Level.INFO);
+        try {
+            var record = record("logged", Map.of("action", "block", "evidence", List.of("evaluation")));
+            new LoggingSemanticAuditSink().append(record);
+            assertThat(messages).hasSize(1);
+            assertThat((JsonObject) Jsoner.deserialize(messages.get(0))).containsEntry("eventId", "logged")
+                    .containsEntry("action", "block").containsEntry("evidence", List.of("evaluation"));
+        } finally {
+            logger.setLevel(previous);
+            logger.removeAppender(appender);
+            appender.stop();
+        }
+    }
+
+    private static SemanticAuditRecord record(String id, Map<String, ?> fields) {
+        Map<String, Object> data
+                = new HashMap<>(Map.of("schemaVersion", 1, "eventId", id, "category", "decision", "timestamp", TIME));
+        data.putAll(fields);
+        return SemanticAuditRecord.fromMap(data);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static List<Map<String, Object>> rows(JsonObject response) {
+        return (List<Map<String, Object>>) response.get("records");
+    }
+
+    private static class Fixture implements AutoCloseable {
+        final DefaultCamelContext context = new DefaultCamelContext();
+        final SemanticAuditConsole console = new SemanticAuditConsole();
+        final MemorySemanticAuditStore store;
+
+        Fixture() throws Exception {
+            SemanticAuditService.get(context).configure("test",
+                    new SemanticAuditConfiguration(true, Map.of(), List.of("memory"), "memory", 10, 10));
+            context.start();
+            store = (MemorySemanticAuditStore) SemanticAuditService.get(context).getReader();
+            console.setCamelContext(context);
+        }
+
+        JsonObject call(Map<String, Object> options) {
+            return (JsonObject) console.call(DevConsole.MediaType.JSON, options);
+        }
+
+        public void close() throws Exception {
+            console.stop();
+            context.close();
+        }
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditRegressionTest.java b/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditRegressionTest.java
new file mode 100644
index 000000000000..b774a6571fb6
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditRegressionTest.java
@@ -0,0 +1,312 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.apache.camel.Predicate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.dsl.yaml.common.YamlDeserializationContext;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.camel.language.semantic.SemanticLanguage;
+import org.apache.camel.semantic.internal.SemanticAuditService;
+import org.apache.camel.support.DefaultExchange;
+import org.apache.camel.support.PluginHelper;
+import org.apache.camel.support.ResourceHelper;
+import org.apache.camel.support.service.ServiceSupport;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.snakeyaml.engine.v2.api.LoadSettings;
+import org.snakeyaml.engine.v2.api.lowlevel.Compose;
+import org.snakeyaml.engine.v2.exceptions.MarkedYamlEngineException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class SemanticAuditRegressionTest {
+    @TempDir
+    Path directory;
+
+    @Test
+    void deletedAuditResourceDoesNotPoisonReloadAndCanMoveWithoutChangingActiveSettings() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert());
+            Path file = Files.createFile(directory.resolve("Original.java"));
+            RouteBuilder original = declarations(context, file);
+            context.addRoutes(original);
+            context.start();
+            var audit = SemanticAuditService.get(context);
+            var config = audit.getConfiguration();
+            Files.delete(file);
+            for (int i = 0; i < 2; i++) {
+                context.addRoutes(new RouteBuilder() {
+                    public void configure() {
+                    }
+                });
+            }
+            assertThat(SemanticEvaluations.get(context).snapshot()).isEmpty();
+            assertThat(audit.getConfiguration()).isEqualTo(config);
+            Path renamed = Files.createFile(directory.resolve("Renamed.java"));
+            context.addRoutes(declarations(context, renamed));
+            assertThat(SemanticEvaluations.get(context).snapshot()).containsKey("check");
+            Files.delete(renamed);
+            SemanticEvaluations.get(context).removeDeletedResources();
+            assertThat(SemanticEvaluations.get(context).snapshot()).isEmpty();
+            assertThatThrownBy(() -> audit.configure("different.yaml", SemanticAuditConfiguration.DISABLED))
+                    .hasMessageContaining("restart");
+        }
+    }
+
+    private RouteBuilder declarations(DefaultCamelContext context, Path path) {
+        var builder = new RouteBuilder() {
+            public void configure() {
+                SemanticEvaluationsBuilder.semanticEvaluations(this).audit(auditConfiguration())
+                        .expert("security").evaluation("check").operation("boolean").register();
+            }
+        };
+        builder.setResource(ResourceHelper.resolveResource(context, path.toUri().toString()));
+        return builder;
+    }
+
+    @Test
+    void preStartInvocationDoesNotFreezeConfigurationAndLateObserversAreExplicitlyStartupOnly() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            var audit = SemanticAuditService.get(context);
+            audit.decision(null, Map.of("action", "continue"), List.of());
+            assertThat(audit.isStarted()).isFalse();
+            audit.configure("audit.yaml", auditConfiguration());
+            AtomicInteger before = new AtomicInteger();
+            AtomicInteger after = new AtomicInteger();
+            context.getRegistry().bind("before", decisionObserver(before));
+            context.start();
+            context.getRegistry().bind("after", decisionObserver(after));
+            audit.decision(null, Map.of("action", "allow"), List.of());
+            assertThatThrownBy(() -> audit.configure("audit.yaml", SemanticAuditConfiguration.DISABLED))
+                    .hasMessageContaining("restart");
+            audit.stop();
+            assertThat(before).hasValue(1);
+            assertThat(after).hasValue(0);
+            assertThat(audit.getReader().query(query()).getRecords()).hasSize(1);
+            audit.configure("audit.yaml", SemanticAuditConfiguration.DISABLED);
+            audit.start();
+            assertThat(audit.status()).containsEntry("observerCount", 2);
+        }
+    }
+
+    @Test
+    void slowReaderStartupCannotBlockRouteObservers() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            var reader = new SlowReader();
+            context.getRegistry().bind("reader", reader);
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", new SemanticAuditConfiguration(false, Map.of(), List.of("memory"), "reader", 10, 10));
+            var decisions = new AtomicInteger();
+            context.getRegistry().bind("observer", decisionObserver(decisions));
+            context.start();
+            var pool = Executors.newFixedThreadPool(2);
+            try {
+                var reading = pool.submit(audit::getReader);
+                assertThat(reader.entered.await(5, TimeUnit.SECONDS)).isTrue();
+                pool.submit(() -> audit.decision(null, Map.of("action", "allow"), List.of())).get(2, TimeUnit.SECONDS);
+                assertThat(decisions).hasValue(1);
+                reader.release.countDown();
+                assertThat(reading.get(5, TimeUnit.SECONDS)).isSameAs(reader);
+            } finally {
+                reader.release.countDown();
+                pool.shutdownNow();
+            }
+        }
+    }
+
+    @Test
+    void capturesStaticProviderAndAllowlistedModelIdentityWithSeparateStartAndCompletionTimes() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert() {
+                public SemanticResult evaluate(SemanticEvaluation evaluation, Object input) {
+                    return new SemanticResult(
+                            true, null, null, null, Map.of(
+                                    "provider", "untrusted-override", "model", "detector-v2", "revision", "abc123",
+                                    "prompt", "secret", "credentials", "secret"));
+                }
+            });
+            var start = new AtomicReference<SemanticAuditRecord>();
+            context.getRegistry().bind("observer", (SemanticObserver) (record, parent) -> {
+                start.set(record);
+                return completed -> {
+                };
+            });
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", auditConfiguration());
+            context.start();
+            ((SemanticLanguage) context.resolveLanguage("semantic"))
+                    .evaluate(new SemanticEvaluation("boolean", "security", null, Map.of()), "secret");
+            audit.stop();
+            var captured = audit.getReader().query(query()).getRecords().get(0);
+            assertThat(captured.toMap()).containsEntry("provider", "test").containsEntry("model", "detector-v2")
+                    .containsEntry("revision", "abc123").doesNotContainKeys("prompt", "credentials", "metadata");
+            assertThat(captured.text("startedAt")).isEqualTo(start.get().text("timestamp"));
+            assertThat(Instant.parse(captured.text("timestamp"))).isAfterOrEqualTo(Instant.parse(captured.text("startedAt")));
+            assertThat(SemanticAuditRecord.fromMap(captured.toMap()).toMap()).isEqualTo(captured.toMap());
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "bad\nmodel", "", "OVERSIZED" })
+    void omitsInvalidModelIdentityWithoutTruncatingIt(String model) throws Exception {
+        String value = "OVERSIZED".equals(model) ? "x".repeat(257) : model;
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert() {
+                public SemanticResult evaluate(SemanticEvaluation evaluation, Object input) {
+                    return new SemanticResult(true, null, null, null, Map.of("model", value, "revision", 123));
+                }
+            });
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", auditConfiguration());
+            context.start();
+            ((SemanticLanguage) context.resolveLanguage("semantic"))
+                    .evaluate(new SemanticEvaluation("boolean", "security", null, Map.of()), "text");
+            audit.stop();
+            assertThat(audit.getReader().query(query()).getRecords().get(0).toMap()).doesNotContainKeys("model", "revision");
+        }
+    }
+
+    @Test
+    void declarationRejectedDuringPredicateUseStillSuppliesDecisionEvidence() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("choice", new ChoiceExpert());
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", auditConfiguration());
+            SemanticEvaluations.get(context).replace("definitions",
+                    Map.of("check", new SemanticEvaluation("choice", "choice", null, Map.of())));
+            context.start();
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("text");
+            Predicate predicate = (Predicate) context.resolveLanguage("semantic").createExpression("ref:check");
+            assertThatThrownBy(() -> predicate.matches(exchange)).hasMessageContaining("boolean");
+            var decision = new SemanticAuditDecision();
+            decision.setFields(Map.of("action", "review", "reasonCode", "invalid_declaration"));
+            decision.process(exchange);
+            audit.stop();
+            var records = audit.getReader().query(query()).getRecords();
+            assertThat(records).hasSize(2);
+            assertThat(records.get(0).toMap()).containsEntry("evidence", List.of(records.get(1).getEventId()));
+            assertThat(records.get(1).toMap()).containsEntry("reasonCode", "invalid_declaration");
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "capacity: 0", "capacity: abc", "queueCapacity: 100001", "sinks: memory" })
+    void yamlAuditErrorsCarryTheSourcePosition(String setting) throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            String yaml = "- semantic:\n    audit:\n      " + setting + "\n";
+            var settings = LoadSettings.builder().setLabel("audit-invalid.yaml").build();
+            try (var dc = new YamlDeserializationContext(settings)) {
+                dc.setCamelContext(context);
+                dc.setResource(ResourceHelper.fromString("audit-invalid.yaml", yaml));
+                dc.start();
+                assertThatThrownBy(() -> dc.preParse(new Compose(settings).composeString(yaml).orElseThrow()))
+                        .isInstanceOf(MarkedYamlEngineException.class).hasMessageContaining("line 3");
+            }
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "capacity='0'", "capacity='abc'", "queueCapacity='100001'" })
+    void xmlCapacityErrorsNameTheOptionAndResource(String setting) throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            assertThatThrownBy(() -> PluginHelper.getRoutesLoader(context).loadRoutes(ResourceHelper.fromString("invalid.xml",
+                    "<semantic><audit " + setting + "/></semantic>")))
+                    .hasMessageContaining(setting.substring(0, setting.indexOf('='))).hasMessageContaining("invalid.xml")
+                    .hasMessageContaining("between 1 and 100000");
+        }
+    }
+
+    @Test
+    void xmlMissingEnabledNamesTheExpert() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            assertThatThrownBy(() -> PluginHelper.getRoutesLoader(context).loadRoutes(ResourceHelper.fromString("invalid.xml",
+                    "<semantic><audit><expert name='security'/></audit></semantic>")))
+                    .hasMessageContaining("security").hasMessageContaining("enabled");
+        }
+    }
+
+    private static SemanticObserver decisionObserver(AtomicInteger counter) {
+        return new SemanticObserver() {
+            public Observation started(SemanticAuditRecord record, Object parent) {
+                return null;
+            }
+
+            public void decision(SemanticAuditRecord record) {
+                counter.incrementAndGet();
+            }
+        };
+    }
+
+    private static SemanticAuditConfiguration auditConfiguration() {
+        return new SemanticAuditConfiguration(true, Map.of(), List.of("memory"), "memory", 20, 20);
+    }
+
+    private static SemanticAuditQuery query() {
+        return new SemanticAuditQuery(Map.of(), null, null, 20);
+    }
+
+    private static class SlowReader extends ServiceSupport implements SemanticAuditReader {
+        final CountDownLatch entered = new CountDownLatch(1);
+        final CountDownLatch release = new CountDownLatch(1);
+
+        protected void doStart() throws Exception {
+            entered.countDown();
+            if (!release.await(5, TimeUnit.SECONDS))
+                throw new IllegalStateException("reader not released");
+        }
+
+        public SemanticAuditPage query(SemanticAuditQuery query) {
+            return new SemanticAuditPage(List.of(), null, 0, false);
+        }
+
+        public Optional<SemanticAuditRecord> get(String id) {
+            return Optional.empty();
+        }
+    }
+
+    @SemanticExpert(name = "choice", description = "Test choice", provider = "test", artifactId = "test",
+                    operations = @SemanticOperation(name = "choice", description = "Choose",
+                                                    inputTypes = SemanticExpert.InputType.TEXT,
+                                                    inputRequirements = "Text", resultType = SemanticExpert.ResultType.CHOICE,
+                                                    resultMeaning = "Chosen label"))
+    private static class ChoiceExpert implements SemanticAdapter {
+        public void validate(SemanticEvaluation evaluation) {
+            SemanticCapabilities.from(getClass()).validate(evaluation);
+        }
+
+        public SemanticResult evaluate(SemanticEvaluation evaluation, Object input) {
+            return new SemanticResult("a", null, null, null, null);
+        }
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditReviewTest.java b/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditReviewTest.java
new file mode 100644
index 000000000000..89ee0011cddc
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditReviewTest.java
@@ -0,0 +1,219 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.time.Instant;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.camel.semantic.internal.SemanticAuditService;
+import org.apache.camel.support.DefaultExchange;
+import org.apache.camel.support.service.ServiceSupport;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class SemanticAuditReviewTest {
+    @ParameterizedTest
+    @ValueSource(strings = { "refs:a,b", "refs:b,a" })
+    void recordsEachReturnedAnswerButStillRejectsTheWholeBatch(String expression) throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert() {
+                @Override
+                public SemanticResult evaluate(SemanticEvaluation evaluation, Object state) {
+                    return new SemanticResult(
+                            evaluation.getParameters().get("threshold").equals(0.2) ? "invalid" : true,
+                            null, null, null, null);
+                }
+            });
+            var audit = configured(context);
+            SemanticEvaluations.get(context).replace("defs", Map.of("a", evaluation(0.1), "b", evaluation(0.2)));
+            context.start();
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("text");
+            assertThatThrownBy(
+                    () -> context.resolveLanguage("semantic").createExpression(expression).evaluate(exchange, Map.class))
+                    .hasMessageContaining("Semantic evaluation 'b'");
+            assertThat(exchange.getProperty("CamelSemanticResults")).isNull();
+            audit.stop();
+            assertThat(rows(audit)).filteredOn(r -> "a".equals(r.text("definition")))
+                    .singleElement().satisfies(r -> assertThat(r.getStatus()).isEqualTo("success"));
+            assertThat(rows(audit)).filteredOn(r -> "b".equals(r.text("definition")))
+                    .singleElement().satisfies(r -> assertThat(r.text("reasonCode")).isEqualTo("invalid_result"));
+        }
+    }
+
+    @Test
+    void validatedMembersAreNotExecutedWhenAnotherInputIsInvalid() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            var expert = new FixedSemanticExpert() {
+                @Override
+                public void validateInput(SemanticEvaluation evaluation, Object state) {
+                    if (evaluation.getParameters().get("threshold").equals(0.2)) {
+                        throw new IllegalArgumentException("invalid input");
+                    }
+                }
+            };
+            context.getRegistry().bind("security", expert);
+            var audit = configured(context);
+            SemanticEvaluations.get(context).replace("defs", Map.of("a", evaluation(0.1), "b", evaluation(0.2)));
+            context.start();
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("text");
+            assertThatThrownBy(
+                    () -> context.resolveLanguage("semantic").createExpression("refs:a,b").evaluate(exchange, Map.class))
+                    .hasMessageContaining("invalid input");
+            audit.stop();
+            assertThat(expert.calls).isZero();
+            assertThat(rows(audit)).filteredOn(r -> "a".equals(r.text("definition")))
+                    .singleElement().satisfies(r -> assertThat(r.getStatus()).isEqualTo("not_executed"));
+            assertThat(rows(audit)).filteredOn(r -> "b".equals(r.text("definition")))
+                    .singleElement().satisfies(r -> assertThat(r.text("reasonCode")).isEqualTo("invalid_input"));
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = { true, false })
+    void expertOnlyCaptureIncludesExplicitDecisions(boolean enabled) throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert());
+            var audit = SemanticAuditService.get(context);
+            audit.configure("audit", new SemanticAuditConfiguration(
+                    false, Map.of("security", enabled),
+                    List.of("memory"), "memory", 10, 10));
+            SemanticEvaluations.get(context).replace("defs", Map.of("a", evaluation(0.1)));
+            context.start();
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("text");
+            context.resolveLanguage("semantic").createExpression("ref:a").evaluate(exchange, Boolean.class);
+            var decision = new SemanticAuditDecision();
+            decision.setFields(Map.of("action", "block"));
+            decision.process(exchange);
+            audit.stop();
+            assertThat(rows(audit)).hasSize(enabled ? 2 : 0);
+            if (enabled) {
+                assertThat(rows(audit).get(0).getEvidence()).containsExactly(rows(audit).get(1).getEventId());
+            } else {
+                assertThat(exchange.getProperty(SemanticAudit.REFERENCES)).isNull();
+            }
+        }
+    }
+
+    @Test
+    void contextRestartRebuildsChangedBackendsAndMemoryCapacity() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            var first = new CountingSink();
+            var second = new CountingSink();
+            context.getRegistry().bind("first", first);
+            context.getRegistry().bind("second", second);
+            var audit = SemanticAuditService.get(context);
+            audit.configure("audit",
+                    new SemanticAuditConfiguration(true, Map.of(), List.of("first", "memory"), "memory", 10, 10));
+            audit.activate();
+            context.start();
+            SemanticAudit.get(context).decision(null, Map.of("action", "allow"), List.of());
+            context.stop();
+            assertThat(first.count).hasValue(1);
+            context.getRegistry().bind("second", second);
+            audit.configure("audit",
+                    new SemanticAuditConfiguration(true, Map.of(), List.of("second", "memory"), "memory", 2, 10));
+            context.start();
+            audit.decision(null, Map.of("action", "block"), List.of());
+            context.stop();
+            assertThat(first.count).hasValue(1);
+            assertThat(first.isStopped()).isTrue();
+            assertThat(second.count).hasValue(1);
+            assertThat(((MemorySemanticAuditStore) audit.getReader()).getCapacity()).isEqualTo(2);
+            assertThat(rows(audit)).singleElement().satisfies(r -> assertThat(r.text("action")).isEqualTo("block"));
+        }
+    }
+
+    @Test
+    void cursorRejectsCollidingFiltersAndNormalizesFilterOrder() throws Exception {
+        var store = new MemorySemanticAuditStore(10);
+        for (String id : List.of("a", "b", "c"))
+            store.append(record(id, "Aa"));
+        var filters = new LinkedHashMap<String, String>();
+        filters.put("expert", "Aa");
+        filters.put("category", "evaluation");
+        var first = store.query(new SemanticAuditQuery(filters, null, null, 1));
+        assertThatThrownBy(() -> store.query(new SemanticAuditQuery(
+                Map.of("expert", "BB", "category", "evaluation"),
+                null, first.getNextCursor(), 1))).isInstanceOf(IllegalArgumentException.class);
+        var reversed = new LinkedHashMap<String, String>();
+        reversed.put("category", "evaluation");
+        reversed.put("expert", "Aa");
+        assertThat(store.query(new SemanticAuditQuery(reversed, null, first.getNextCursor(), 1)).getRecords())
+                .extracting(SemanticAuditRecord::getEventId).containsExactly("b");
+        assertThatThrownBy(() -> store.query(new SemanticAuditQuery(filters, Instant.EPOCH, first.getNextCursor(), 1)))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    void persistedRecordsValidateTypesAndPreserveFieldOrder() {
+        var fields = new LinkedHashMap<String, Object>();
+        fields.put("schemaVersion", 1);
+        fields.put("eventId", "record");
+        fields.put("category", "evaluation");
+        fields.put("timestamp", "2026-10-10T00:00:00Z");
+        fields.put("expert", "security");
+        var record = SemanticAuditRecord.fromMap(fields);
+        assertThat(record.toMap().keySet()).containsExactlyElementsOf(fields.keySet());
+        assertThat(record.getTimestamp()).isEqualTo(Instant.parse("2026-10-10T00:00:00Z"));
+        assertThat(new SemanticAuditQuery(Map.of("expert", "security"), record.getTimestamp(), null, 1).matches(record))
+                .isTrue();
+        for (var invalid : Map.<String, Object> of("expert", 42, "durationNanos", -1, "semantics", Map.of("meaning", 3),
+                "result", Map.of("value", Map.of("unexpected", true))).entrySet()) {
+            var broken = new LinkedHashMap<>(fields);
+            broken.put(invalid.getKey(), invalid.getValue());
+            assertThatThrownBy(() -> SemanticAuditRecord.fromMap(broken)).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    private static SemanticAuditService configured(DefaultCamelContext context) {
+        var audit = SemanticAuditService.get(context);
+        audit.configure("audit", new SemanticAuditConfiguration(true, Map.of(), List.of("memory"), "memory", 100, 100));
+        return audit;
+    }
+
+    private static SemanticEvaluation evaluation(double threshold) {
+        return new SemanticEvaluation("boolean", "security", "${body}", Map.of("threshold", threshold));
+    }
+
+    private static List<SemanticAuditRecord> rows(SemanticAuditService audit) throws Exception {
+        return audit.getReader().query(new SemanticAuditQuery(Map.of(), null, null, 100)).getRecords();
+    }
+
+    private static SemanticAuditRecord record(String id, String expert) {
+        return SemanticAuditRecord.fromMap(Map.of("schemaVersion", 1, "eventId", id, "category", "evaluation",
+                "timestamp", "2026-10-10T00:00:00Z", "expert", expert));
+    }
+
+    private static class CountingSink extends ServiceSupport implements SemanticAuditSink {
+        private final AtomicInteger count = new AtomicInteger();
+
+        public void append(SemanticAuditRecord record) {
+            count.incrementAndGet();
+        }
+    }
+}
diff --git a/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditTest.java b/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditTest.java
new file mode 100644
index 000000000000..9c7f58ef0c59
--- /dev/null
+++ b/components/camel-ai/camel-semantic/src/test/java/org/apache/camel/semantic/SemanticAuditTest.java
@@ -0,0 +1,603 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.semantic;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.console.DevConsole;
+import org.apache.camel.dsl.yaml.common.YamlDeserializationContext;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.camel.language.semantic.SemanticLanguage;
+import org.apache.camel.semantic.internal.SemanticAuditService;
+import org.apache.camel.support.DefaultExchange;
+import org.apache.camel.support.PluginHelper;
+import org.apache.camel.support.ResourceHelper;
+import org.apache.camel.support.service.ServiceSupport;
+import org.apache.camel.util.json.JsonObject;
+import org.apache.camel.util.json.Jsoner;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.snakeyaml.engine.v2.api.LoadSettings;
+import org.snakeyaml.engine.v2.api.lowlevel.Compose;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.awaitility.Awaitility.await;
+
+class SemanticAuditTest {
+    @ParameterizedTest
+    @CsvSource({
+            "false,inherit,false", "false,true,true", "false,false,false", "true,inherit,true", "true,true,true",
+            "true,false,false" })
+    void expertOverridesMasterWithoutChangingInference(boolean master, String override, boolean expected) throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            FixedSemanticExpert expert = new FixedSemanticExpert();
+            context.getRegistry().bind("security", expert);
+            SemanticAuditService audit = SemanticAuditService.get(context);
+            audit.configure("test", configuration(master,
+                    override.equals("inherit") ? Map.of() : Map.of("security", Boolean.valueOf(override))));
+            context.start();
+            SemanticLanguage language = (SemanticLanguage) context.resolveLanguage("semantic");
+            assertThat(language.evaluate(evaluation("security"), "secret input").getValue()).isEqualTo(true);
+            audit.stop();
+            assertThat(records(audit)).hasSize(expected ? 1 : 0);
+            assertThat(expert.calls).isEqualTo(1);
+        }
+    }
+
+    @Test
+    void telemetryObservesWhenAuditIsDisabledAndCarriesParentAcrossConsoleExecutor() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert());
+            Object parent = new Object();
+            AtomicInteger completions = new AtomicInteger();
+            context.getRegistry().bind("telemetry", new SemanticObserver() {
+                public Object captureContext() {
+                    return parent;
+                }
+
+                public Observation started(SemanticAuditRecord record, Object captured) {
+                    assertThat(captured).isSameAs(parent);
+                    return completed -> {
+                        assertThat(completed.getStatus()).isEqualTo("success");
+                        completions.incrementAndGet();
+                    };
+                }
+            });
+            context.start();
+            SemanticEvaluateConsole console = new SemanticEvaluateConsole();
+            console.setCamelContext(context);
+            try {
+                var result = console.call(DevConsole.MediaType.JSON,
+                        Map.of("expert", "security", "operation", "boolean", "input", "private"));
+                assertThat(((Map<?, ?>) result).get("status")).isEqualTo("success");
+                assertThat(completions).hasValue(1);
+                SemanticAuditService.get(context).stop();
+                assertThat(records(SemanticAuditService.get(context))).isEmpty();
+            } finally {
+                console.stop();
+            }
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "refs:a,b", "refs:b,a" })
+    void batchingAliasesUsesEachDeclarationsEffectiveExpert(String expression) throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            var expert = new FixedSemanticExpert();
+            context.getRegistry().bind("recorded", expert);
+            context.getRegistry().bind("excluded", expert);
+            var language = (SemanticLanguage) context.resolveLanguage("semantic");
+            language.setDefaultExpert("excluded");
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", configuration(true, Map.of("excluded", false, "recorded", true)));
+            SemanticEvaluations.get(context).replace("definitions", Map.of("a", evaluation("recorded"), "b", evaluation(null)));
+            context.start();
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("text");
+            assertThat(language.createExpression(expression).evaluate(exchange, Map.class)).hasSize(2);
+            assertThat(expert.batches).hasSize(1);
+            audit.stop();
+            assertThat(records(audit)).hasSize(1);
+            assertThat(records(audit).get(0).getExpert()).isEqualTo("recorded");
+            assertThat(records(audit).get(0).text("definition")).isEqualTo("a");
+        }
+    }
+
+    @Test
+    void namedBatchKeepsProviderBatchingAndExplicitDecisionLinks() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            FixedSemanticExpert expert = new FixedSemanticExpert();
+            context.getRegistry().bind("security", expert);
+            var audit = SemanticAuditService.get(context);
+            audit.configure("audit", configuration(true, Map.of()));
+            SemanticEvaluations.get(context).replace("definitions",
+                    Map.of("first", evaluation("security"), "second", evaluation("security")));
+            context.start();
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("private");
+            context.resolveLanguage("semantic").createExpression("refs:first,second").evaluate(exchange, Map.class);
+            assertThat(expert.batches).containsExactly(List.of("first", "second"));
+            SemanticAuditDecision decision = new SemanticAuditDecision();
+            decision.setFields(Map.of("action", "block", "reasonCode", "prompt_injection", "operation", "tools/call", "target",
+                    "support-request"));
+            decision.process(exchange);
+            audit.stop();
+            List<SemanticAuditRecord> records = records(audit);
+            assertThat(records).hasSize(3);
+            assertThat(records).filteredOn(r -> r.getCategory().equals("evaluation")).allSatisfy(r -> {
+                assertThat(r.toMap()).doesNotContainKey("action");
+                assertThat(r.getStatus()).isEqualTo("success");
+            });
+            assertThat(records.get(0).toMap().get("evidence")).isEqualTo(exchange.getProperty(SemanticAuditService.REFERENCES));
+            assertThat(records.get(0).text("action")).isEqualTo("block");
+            assertThat(records.get(1).text("batchId")).isEqualTo(records.get(2).text("batchId"));
+            assertThat(records.get(1).getInvocationId()).isNotEqualTo(records.get(2).getInvocationId());
+        }
+    }
+
+    @Test
+    void capturesFailuresAndUnexecutedGroupsWithoutRawExceptions() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            FixedSemanticExpert first = new FixedSemanticExpert();
+            first.fail = true;
+            FixedSemanticExpert second = new FixedSemanticExpert();
+            context.getRegistry().bind("first", first);
+            context.getRegistry().bind("second", second);
+            var audit = SemanticAuditService.get(context);
+            audit.configure("audit", configuration(true, Map.of()));
+            SemanticEvaluations.get(context).replace("definitions",
+                    Map.of("a", evaluation("first"), "b", evaluation("second")));
+            context.start();
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("secret");
+            var expression = context.resolveLanguage("semantic").createExpression("refs:a,b");
+            assertThatThrownBy(() -> expression.evaluate(exchange, Map.class)).hasMessageContaining("provider unavailable");
+            audit.stop();
+            assertThat(records(audit)).hasSize(2).anySatisfy(r -> assertThat(r.getStatus()).isEqualTo("not_executed"))
+                    .anySatisfy(r -> assertThat(r.text("reasonCode")).isEqualTo("provider_error"));
+            assertThat(second.calls).isZero();
+            assertThat(records(audit).toString()).doesNotContain("secret", "provider unavailable");
+        }
+    }
+
+    @Test
+    void safeSnapshotSurvivesObserverAndSinkFailures() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert() {
+                public SemanticResult evaluate(SemanticEvaluation evaluation, Object state) {
+                    return new SemanticResult(true, 0.9, null, null, Map.of("input", state, "token", "private-token"));
+                }
+            });
+            context.getRegistry().bind("broken", new BrokenSink());
+            context.getRegistry().bind("observer", (SemanticObserver) (record, parent) -> {
+                throw new AssertionError("private-observer-error");
+            });
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test",
+                    new SemanticAuditConfiguration(true, Map.of(), List.of("broken", "memory"), "memory", 10, 10));
+            context.start();
+            var language = (SemanticLanguage) context.resolveLanguage("semantic");
+            assertThat(language.evaluate(evaluation("security"), "secret-body").getValue()).isEqualTo(true);
+            audit.stop();
+            var record = records(audit).get(0);
+            assertThat(new JsonObject(record.toMap()).toJson()).doesNotContain("secret-body", "private-token",
+                    "private-observer-error", "metadata");
+            assertThat(audit.status()).containsEntry("observerErrors", 1L);
+            assertThat(((Map<?, ?>) audit.status().get("sinkErrors")).get("broken")).isEqualTo(1L);
+            assertThatThrownBy(() -> record.toMap().put("body", "bad")).isInstanceOf(UnsupportedOperationException.class);
+        }
+    }
+
+    @Test
+    void boundedHistoryHasStablePagesAndReportsEviction() throws Exception {
+        var store = new MemorySemanticAuditStore(3);
+        for (int i = 0; i < 3; i++) {
+            store.append(record("e" + i));
+        }
+        var first = store.query(new SemanticAuditQuery(Map.of(), null, null, 2));
+        assertThat(first.getRecords()).extracting(SemanticAuditRecord::getEventId).containsExactly("e2", "e1");
+        store.append(record("e3"));
+        var next = store.query(new SemanticAuditQuery(Map.of(), null, first.getNextCursor(), 2));
+        assertThat(next.getRecords()).isEmpty();
+        assertThat(next.isCursorExpired()).isTrue();
+        assertThat(next.getEvicted()).isEqualTo(1);
+        assertThat(store.get("e0")).isEmpty();
+        assertThatThrownBy(
+                () -> store.query(new SemanticAuditQuery(Map.of("expert", "security"), null, first.getNextCursor(), 2)))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    void yamlDeclaresMasterAndTwoExpertOverridesAndRejectsConflictingReload() throws Exception {
+        String yaml = """
+                - semantic:
+                    audit:
+                      enabled: true
+                      experts:
+                        security: {enabled: true}
+                        decisions: {enabled: false}
+                      sinks: [memory, log]
+                      capacity: 25
+                    evaluation:
+                      check: {expert: security, operation: boolean}
+                """;
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert());
+            preParse(context, yaml);
+            var audit = SemanticAuditService.get(context);
+            assertThat(audit.getConfiguration().isEnabled("security")).isTrue();
+            assertThat(audit.getConfiguration().isEnabled("decisions")).isFalse();
+            context.start();
+            assertThatThrownBy(() -> preParse(context, yaml.replace("enabled: true", "enabled: false")))
+                    .hasMessageContaining("restart");
+            assertThat(audit.getConfiguration().isEnabled()).isTrue();
+            assertThat(SemanticEvaluations.get(context).get("check")).isNotNull();
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = { true, false })
+    void timeoutAndLateProviderCompletionRespectExpertOverride(boolean enabled) throws Exception {
+        CountDownLatch release = new CountDownLatch(1);
+        CountDownLatch entered = new CountDownLatch(1);
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert() {
+                public SemanticResult evaluate(SemanticEvaluation evaluation, Object state) {
+                    entered.countDown();
+                    boolean interrupted = false;
+                    while (true) {
+                        try {
+                            if (!release.await(5, TimeUnit.SECONDS)) {
+                                throw new IllegalStateException("test timed out");
+                            }
+                            break;
+                        } catch (InterruptedException e) {
+                            interrupted = true;
+                        }
+                    }
+                    if (interrupted) {
+                        Thread.currentThread().interrupt();
+                    }
+                    return new SemanticResult(true, 0.9, null, null, null);
+                }
+            });
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", configuration(true, Map.of("security", enabled)));
+            context.start();
+            SemanticEvaluateConsole console = new SemanticEvaluateConsole();
+            console.setCamelContext(context);
+            try {
+                var answer = console.call(DevConsole.MediaType.JSON,
+                        Map.of("expert", "security", "operation", "boolean", "input", "secret", "timeout", 100));
+                assertThat(entered.await(2, TimeUnit.SECONDS)).isTrue();
+                assertThat(((Map<?, ?>) answer).get("status")).isEqualTo("failed");
+                release.countDown();
+                if (enabled) {
+                    await().atMost(5, TimeUnit.SECONDS).untilAsserted(() -> assertThat(records(audit)).hasSize(2));
+                }
+                console.stop();
+                audit.stop();
+                var records = records(audit);
+                if (!enabled) {
+                    assertThat(records).isEmpty();
+                    return;
+                }
+                assertThat(records).hasSize(2);
+                assertThat(records).extracting(SemanticAuditRecord::getCategory).containsExactlyInAnyOrder("evaluation",
+                        "request");
+                assertThat(records.get(0).getInvocationId()).isEqualTo(records.get(1).getInvocationId());
+                assertThat(records).anySatisfy(r -> assertThat(r.getStatus()).isEqualTo("success"));
+            } finally {
+                release.countDown();
+                console.stop();
+            }
+        } finally {
+            release.countDown();
+        }
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "true,security", "false,security", "true,{{expert.name}}", "false,{{expert.name}}", "true,default",
+            "false,default" })
+    void invalidDeclarationsResolveExpertPlaceholdersBeforeAuditFiltering(boolean enabled, String expert) throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert());
+            Properties properties = new Properties();
+            properties.put("expert.name", "security");
+            context.getPropertiesComponent().setInitialProperties(properties);
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", configuration(true, Map.of("security", enabled)));
+            context.start();
+            var language = (SemanticLanguage) context.resolveLanguage("semantic");
+            language.setDefaultExpert("security");
+            assertThatThrownBy(() -> language.evaluate(
+                    new SemanticEvaluation("unknown", "default".equals(expert) ? null : expert, null, Map.of()), "text"))
+                    .isInstanceOf(IllegalArgumentException.class);
+            audit.stop();
+            assertThat(records(audit)).hasSize(enabled ? 1 : 0);
+            if (enabled) {
+                assertThat(records(audit).get(0).getExpert()).isEqualTo("security");
+            }
+        }
+    }
+
+    @Test
+    void timeoutDuringExpertResolutionCannotBypassAnExclusion() throws Exception {
+        CountDownLatch entered = new CountDownLatch(1);
+        CountDownLatch release = new CountDownLatch(1);
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert() {
+                public void validate(SemanticEvaluation evaluation) {
+                    entered.countDown();
+                    try {
+                        if (!release.await(5, TimeUnit.SECONDS)) {
+                            throw new IllegalStateException("test timed out");
+                        }
+                    } catch (InterruptedException failure) {
+                        Thread.currentThread().interrupt();
+                        throw new IllegalStateException(failure);
+                    }
+                    super.validate(evaluation);
+                }
+            });
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", configuration(true, Map.of("security", false)));
+            context.start();
+            var console = new SemanticEvaluateConsole();
+            console.setCamelContext(context);
+            try {
+                console.call(DevConsole.MediaType.JSON,
+                        Map.of("expert", "security", "operation", "boolean", "input", "secret", "timeout", 100));
+                assertThat(entered.await(2, TimeUnit.SECONDS)).isTrue();
+                release.countDown();
+                console.stop();
+                audit.stop();
+                assertThat(records(audit)).isEmpty();
+            } finally {
+                release.countDown();
+                console.stop();
+            }
+        } finally {
+            release.countDown();
+        }
+    }
+
+    @Test
+    void removedDefinitionIsNotAttributedToTheDefaultExpert() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert());
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", configuration(true, Map.of()));
+            var definitions = SemanticEvaluations.get(context);
+            definitions.replace("definitions", Map.of("check", evaluation("security")));
+            context.start();
+            var language = (SemanticLanguage) context.resolveLanguage("semantic");
+            language.setDefaultExpert("security");
+            var expression = language.createExpression("ref:check");
+            definitions.replace("definitions", Map.of());
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("text");
+            assertThatThrownBy(() -> expression.evaluate(exchange, Boolean.class))
+                    .hasMessageContaining("Unknown semantic evaluation");
+            audit.stop();
+            assertThat(records(audit)).isEmpty();
+        }
+    }
+
+    @Test
+    void disabledCaptureDoesNotStartSinksOrCreateEvidence() throws Exception {
+        try (var context = new DefaultCamelContext()) {
+            var sink = new BrokenSink();
+            context.getRegistry().bind("unused", sink);
+            context.getRegistry().bind("security", new FixedSemanticExpert());
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test",
+                    new SemanticAuditConfiguration(false, Map.of(), List.of("unused", "memory"), "memory", 10, 10));
+            SemanticEvaluations.get(context).replace("definitions", Map.of("check", evaluation("security")));
+            context.start();
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("text");
+            assertThat(context.resolveLanguage("semantic").createExpression("ref:check").evaluate(exchange, Boolean.class))
+                    .isTrue();
+            assertThat(exchange.getProperty(SemanticAuditService.REFERENCES)).isNull();
+            assertThat(sink.isStarted()).isFalse();
+            assertThat(audit.status()).containsEntry("dropped", 0L);
+        }
+    }
+
+    @Test
+    void detachedBatchObservationsKeepTheSameParentAndDoNotLeakThreadContext() throws Exception {
+        ThreadLocal<Object> ambient = new ThreadLocal<>();
+        Object parent = new Object();
+        ambient.set(parent);
+        List<Object> parents = new ArrayList<>();
+        AtomicInteger completed = new AtomicInteger();
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert() {
+                public Map<String, SemanticResult> evaluateBatch(Map<String, SemanticEvaluation> evaluations, Object state)
+                        throws Exception {
+                    assertThat(ambient.get()).isSameAs(parent);
+                    return super.evaluateBatch(evaluations, state);
+                }
+            });
+            context.getRegistry().bind("observer", new SemanticObserver() {
+                public Object captureContext() {
+                    return ambient.get();
+                }
+
+                public Observation started(SemanticAuditRecord record, Object captured) {
+                    parents.add(captured);
+                    Object previous = ambient.get();
+                    ambient.set(record.getInvocationId());
+                    try {
+                        return result -> {
+                            assertThat(ambient.get()).isSameAs(parent);
+                            completed.incrementAndGet();
+                        };
+                    } finally {
+                        ambient.set(previous);
+                    }
+                }
+            });
+            SemanticEvaluations.get(context).replace("definitions",
+                    Map.of("a", evaluation("security"), "b", evaluation("security")));
+            context.start();
+            var exchange = new DefaultExchange(context);
+            exchange.getMessage().setBody("text");
+            context.resolveLanguage("semantic").createExpression("refs:a,b").evaluate(exchange, Map.class);
+            assertThat(parents).containsExactly(parent, parent);
+            assertThat(completed).hasValue(2);
+            assertThat(ambient.get()).isSameAs(parent);
+        } finally {
+            ambient.remove();
+        }
+    }
+
+    @Test
+    void fullQueueDropsNewRecordsAndDrainsAcceptedRecordsOnStop() throws Exception {
+        CountDownLatch entered = new CountDownLatch(1);
+        CountDownLatch release = new CountDownLatch(1);
+        try (var context = new DefaultCamelContext()) {
+            context.getRegistry().bind("security", new FixedSemanticExpert());
+            context.getRegistry().bind("slow", new BrokenSink() {
+                public void append(SemanticAuditRecord record) {
+                    entered.countDown();
+                    try {
+                        assertThat(release.await(5, TimeUnit.SECONDS)).isTrue();
+                    } catch (InterruptedException failure) {
+                        Thread.currentThread().interrupt();
+                        throw new IllegalStateException(failure);
+                    }
+                }
+            });
+            var audit = SemanticAuditService.get(context);
+            audit.configure("test", new SemanticAuditConfiguration(true, Map.of(), List.of("slow", "memory"), "memory", 10, 1));
+            context.start();
+            var language = (SemanticLanguage) context.resolveLanguage("semantic");
+            language.evaluate(evaluation("security"), "one");
+            assertThat(entered.await(5, TimeUnit.SECONDS)).isTrue();
+            language.evaluate(evaluation("security"), "two");
+            language.evaluate(evaluation("security"), "three");
+            assertThat(audit.status()).containsEntry("dropped", 1L);
+            release.countDown();
+            audit.stop();
+            assertThat(records(audit)).hasSize(2);
+        } finally {
+            release.countDown();
+        }
+    }
+
+    @Test
+    void persistedSnapshotsRoundTripAndRejectUnexpectedData() throws Exception {
+        Map<String, Object> fields = new LinkedHashMap<>(
+                Map.of("schemaVersion", 1, "eventId", "e1", "category", "evaluation",
+                        "timestamp", Instant.now().toString(), "result",
+                        new LinkedHashMap<>(Map.of("value", List.of("A", "B"), "probabilities", Map.of("A", 0.7)))));
+        var copy = SemanticAuditRecord.fromMap((Map<String, ?>) Jsoner.deserialize(new JsonObject(fields).toJson()));
+        fields.clear();
+        assertThat(copy.getEventId()).isEqualTo("e1");
+        assertThatThrownBy(() -> ((Map<String, Object>) copy.toMap().get("result")).put("body", "secret"))
+                .isInstanceOf(UnsupportedOperationException.class);
+        var invalid = new LinkedHashMap<>(copy.toMap());
+        invalid.put("result", Map.of("metadata", "secret"));
+        assertThatThrownBy(() -> SemanticAuditRecord.fromMap(invalid)).isInstanceOf(IllegalArgumentException.class);
+        invalid.put("result", Map.of("value", true));
+        invalid.put("schemaVersion", 1.5);
+        assertThatThrownBy(() -> SemanticAuditRecord.fromMap(invalid)).isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    void javaAndXmlConfigureTheSameMasterAndExpertOverrides() throws Exception {
+        for (boolean xml : List.of(true, false)) {
+            try (var context = new DefaultCamelContext()) {
+                context.getRegistry().bind("security", new FixedSemanticExpert());
+                if (xml) {
+                    context.build();
+                    PluginHelper.getRoutesLoader(context).loadRoutes(ResourceHelper.fromString("audit.xml",
+                            """
+                                    <semantic xmlns="http://camel.apache.org/schema/semantic">
+                                      <audit enabled="false" capacity="20"><expert name="security" enabled="true"/><sink ref="memory"/></audit>
+                                      <evaluation name="check" expert="security" operation="boolean"/>
+                                    </semantic>
+                                    """));
+                } else {
+                    context.addRoutes(new RouteBuilder() {
+                        public void configure() {
+                            SemanticEvaluationsBuilder.semanticEvaluations(this)
+                                    .audit(SemanticAuditTest.configuration(false, Map.of("security", true)))
+                                    .evaluation("check").expert("security").operation("boolean").end().register();
+                        }
+                    });
+                }
+                context.start();
+                var exchange = new DefaultExchange(context);
+                exchange.getMessage().setBody("text");
+                assertThat(context.resolveLanguage("semantic").createExpression("ref:check").evaluate(exchange, Boolean.class))
+                        .isTrue();
+                var audit = SemanticAuditService.get(context);
+                audit.stop();
+                assertThat(records(audit)).hasSize(1);
+                assertThat(audit.getConfiguration().isEnabled()).isFalse();
+            }
+        }
+    }
+
+    private static SemanticAuditConfiguration configuration(boolean enabled, Map<String, Boolean> experts) {
+        return new SemanticAuditConfiguration(enabled, experts, List.of("memory"), "memory", 100, 100);
+    }
+
+    private static SemanticEvaluation evaluation(String expert) {
+        return new SemanticEvaluation("boolean", expert, null, Map.of());
+    }
+
+    private static List<SemanticAuditRecord> records(SemanticAuditService audit) throws Exception {
+        return audit.getReader().query(new SemanticAuditQuery(Map.of(), null, null, 200)).getRecords();
+    }
+
+    private static SemanticAuditRecord record(String id) {
+        return new SemanticAuditRecord(Map.of("eventId", id, "timestamp", Instant.now().toString(), "category", "evaluation"));
+    }
+
+    private static void preParse(DefaultCamelContext context, String yaml) throws Exception {
+        var settings = LoadSettings.builder().setLabel("audit.yaml").build();
+        try (var deserialization = new YamlDeserializationContext(settings)) {
+            deserialization.setCamelContext(context);
+            deserialization.setResource(ResourceHelper.fromString("audit.yaml", yaml));
+            deserialization.start();
+            deserialization.preParse(new Compose(settings).composeString(yaml).orElseThrow());
+        }
+    }
+
+    private static class BrokenSink extends ServiceSupport implements SemanticAuditSink {
+        public void append(SemanticAuditRecord record) {
+            throw new IllegalStateException("secret-sink-error");
+        }
+    }
+}
diff --git a/design/semantic-audit.adoc b/design/semantic-audit.adoc
new file mode 100644
index 000000000000..79a3a604127a
--- /dev/null
+++ b/design/semantic-audit.adoc
@@ -0,0 +1,56 @@
+= Semantic audit and observation proposal
+
+Status: proposed for review in CAMEL-25499 / PR #27649. This document describes the implementation being
+reviewed; it does not assert prior upstream design agreement.
+
+== Scope and related work
+
+CAMEL-25357 proposes semantic metadata and a bounded recent-evaluation recorder. Metadata and evaluation
+tooling already exist from CAMEL-25491. The memory sink/reader in this change implements the remaining
+recent-history role; a second recorder should not be added for CAMEL-25357. Its live-capacity proposal is
+replaced here by configuration changes while stopped. The relationship and this tradeoff remain subject
+to maintainer acceptance. No issue is closed by this proposal.
+
+The runtime/SPI and DSL, connector, TUI/MCP, and CLI retrieval are separate layers and commits. Runtime
+capture requires none of the presentation modules. Keeping these layers in one review demonstrates the
+complete path; they can be reviewed independently. Delivery is bounded and best-effort, not a durable
+compliance transaction. CAMEL-23369 can consume the independent observer SPI through Camel telemetry;
+this change adds neither a second OpenTelemetry SDK nor an exporter.
+
+== Configuration and decisions
+
+The first implementation uses semantic DSL configuration, as selected for this implementation. Properties
+remain a valid alternative for deployment-specific control. DSL placeholders support such values without
+introducing two competing configuration authorities. A second properties hierarchy is not rejected in
+principle, but would need an explicit precedence contract before being introduced.
+
+The global switch is a default; explicit expert-instance overrides win in both directions. Explicit route
+decisions are recorded whenever the global default or any expert override enables capture. This preserves
+decisions in the common global-off/security-on case without guessing which supporting expert owns an action.
+Per-expert exclusions apply to evaluation records, so referenced evidence can be unavailable. Routes always
+declare actions explicitly; a boolean expert result never implies allow or block.
+
+Settings remain frozen while the audit service runs. Stop/start permits reconfiguration, resolves backends
+again and rebuilds the bounded memory store if capacity changes. Ordinary source reload does not change
+capture policy. Deleting the declaring resource removes its evaluations but preserves active settings until
+stop; a new start without that declaration uses disabled defaults.
+
+== API and observation
+
+The public backend contract consists of the sink, reader, query, page and immutable record. Records retain
+a versioned map serialization with field/type allowlists and typed timestamp, duration and evidence accessors.
+Readers can reuse public exact-filter matching. The internal dispatcher owns request identities, invocation
+handles, service startup and exchange transport; these are not extension points.
+
+The route-facing SemanticAudit facade and SemanticAuditDecision processor expose explicit decisions and the
+documented evidence property. Observers receive bounded snapshots independently of capture settings. Start
+and completion run on the invocation thread. Cancellation is a separate request event, not concurrent
+completion. Completion reverses start-callback order; registry insertion order is not promised.
+
+== Query surfaces
+
+All retrieval uses the same reader and console. The CLI exposes filters, cursor pages and event/evidence
+lookup. The TUI maintains its own browsing state. Its audit MCP tool queries the runtime directly without
+changing the screen, and is added to AI sessions only when the selected integration exposes audit history.
+The memory reader filters a consistent snapshot outside its append lock and binds cursors to a canonical
+SHA-256 query fingerprint. Backend failures expose a stable error code without backend messages.
diff --git a/docs/user-manual/modules/ROOT/pages/camel-jbang-managing.adoc b/docs/user-manual/modules/ROOT/pages/camel-jbang-managing.adoc
index ae6f8f8413c1..ac9b0e980060 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-jbang-managing.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-jbang-managing.adoc
@@ -284,7 +284,7 @@ TIP: Separate multiple IDs with commas: `--id=log1,log2,setBody2`.
 The CLI can inspect and try the running application's
 xref:next@components:languages:semantic-language.adoc[semantic definitions and experts].
 The application must run Camel 4.23 or newer, include `camel-semantic` with the
-`semantic-metadata` and `semantic-evaluate` developer consoles, and have the local
+`semantic-metadata`, `semantic-evaluate` and `semantic-audit` developer consoles, and have the local
 CLI connector enabled.
 These commands use the connector; enabling the HTTP console is unnecessary.
 
@@ -344,13 +344,50 @@ reply (default: 60000 milliseconds). A CLI timeout removes its request and asks
 connector to cancel unfinished work. Provider interruption is cooperative; remote or
 native inference may continue. Configure provider-specific request timeouts as well.
 
-Both commands accept an integration name or PID. With no name they select the only
+All semantic commands accept an integration name or PID. With no name they select the only
 running integration; ambiguous selection fails and lists the matching PIDs.
 Known versions older than 4.23 fail immediately with exit code 3. If the runtime version
 is unavailable, the CLI attempts the request and applies the normal timeout.
 Each request has its own reply file, so concurrent commands do not consume each
 other's results.
 
+=== Semantic audit history
+
+Use `camel semantic audit` to retrieve retained history from the application's configured
+audit reader. It uses the local connector and performs no inference. Capture settings
+remain in the semantic DSL; querying does not enable auditing or change its configuration.
+
+[source,bash]
+----
+camel semantic audit my-app
+camel semantic audit my-app --category=decision --action=block --limit=20
+camel semantic audit my-app --expert=guard --since=2026-10-10T08:00:00Z --json
+camel semantic audit my-app --event-id=EVENT_ID --json
+----
+
+The default output is a table of event IDs, timestamps, categories, explicit route actions,
+evaluation statuses, experts, operations, targets, namespaces, reason codes and correlation
+IDs. It also reports audit backend status, dropped records and evictions. An evaluation
+status is separate from an application's allow/block decision.
+
+`--json` returns the complete runtime response as one JSON document. `--event-id` selects
+one historical record and its linked evaluation evidence, including any retained provider,
+model, revision and result semantics. Missing linked records carry `unavailable: true`.
+A missing selected event returns exit code 3. Event lookup cannot be combined with list
+filters, `--cursor` or `--limit`.
+
+Pages are newest first, with a default limit of 50 and a maximum of 200. The exact-match
+filters are `--category`, `--action`, `--expert`, `--route-id`, `--namespace` and
+`--correlation-id`. `--since` is inclusive and accepts an ISO-8601 timestamp with a UTC
+offset. Supply a returned `nextCursor` using `--cursor` to retrieve an older page, retaining
+the same filters. Cursors are opaque and belong to the configured backend.
+
+An expired cursor returns exit code 1 and `cursorExpired: true`; start a new query without
+`--cursor`. Backend query failures also return exit code 1 and retain the stable
+`audit_query_failed` error code. An empty history is a successful query: capture may be
+disabled, no events may match, or records may have been evicted. Retained records remain
+readable even when their expert or definition is no longer available.
+
 === Semantic command output and exit codes
 
 With `--json`, stdout contains exactly one JSON document. Inspection returns the
@@ -362,16 +399,17 @@ result fields, such as `error` and `elapsedMillis`. Diagnostics go to stderr.
 [cols="1,4",options="header"]
 |===
 | Exit code | Meaning
-| 0 | Successful inspection or evaluation, including a boolean result of `false`.
-| 1 | The integration rejected the action or evaluation failed.
+| 0 | Successful inspection, audit retrieval (including empty history) or evaluation, including a boolean result of `false`.
+| 1 | The integration rejected the action, evaluation or audit query failed, or an audit cursor expired.
 | 2 | Invalid command arguments or sample values.
-| 3 | No matching integration, ambiguous selection, unavailable semantic tooling or expert operations.
+| 3 | No matching integration, ambiguous selection, unavailable semantic tooling, expert operations or selected audit event.
 | 4 | No reply before the CLI timeout.
 | 70 | Unexpected local CLI error; stderr includes the stack trace.
 |===
 
-See xref:jbang-commands/camel-jbang-semantic-get.adoc[camel semantic get] and
-xref:jbang-commands/camel-jbang-semantic-eval.adoc[camel semantic eval]
+See xref:jbang-commands/camel-jbang-semantic-get.adoc[camel semantic get],
+xref:jbang-commands/camel-jbang-semantic-eval.adoc[camel semantic eval] and
+xref:jbang-commands/camel-jbang-semantic-audit.adoc[camel semantic audit]
 for the complete option reference.
 
 == Developer Console
diff --git a/docs/user-manual/modules/ROOT/pages/camel-jbang-tui-observe.adoc b/docs/user-manual/modules/ROOT/pages/camel-jbang-tui-observe.adoc
index e2ff5eca7bad..a1e331ffb55b 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-jbang-tui-observe.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-jbang-tui-observe.adoc
@@ -461,3 +461,20 @@ An open sample popup accepts `sample` for the complete exchange JSON, `sample.bo
 and `sample.headers` or `sample.variables` for JSON objects. Use the complete `sample` field for a
 structured body. Fields cannot be edited while their evaluation is pending. Edits remain visible in
 the TUI and use the same validation as manual input; send *Ctrl+r* explicitly to evaluate.
+
+
+=== Semantic audit history
+
+The *Audit* view in the Semantic tab browses retained evaluations and explicit route
+policy decisions. Configure capture in the semantic DSL. Auditing works without a TUI
+connection and is independent of OpenTelemetry.
+
+Use `/` for exact `field=value` filters (`category`, `action`, `expert`, `routeId`,
+`namespace`, `correlationId`, `since`), `n` for older records, `g` for the latest page and `r` to refresh.
+Select a record and use `Tab` to focus its inspector, then use the arrows to scroll details and linked evidence. The view reports
+evictions and delivery failures; the built-in memory backend is recent history, not
+persistent storage. The read-only `tui_get_audit` MCP tool queries the same history, linked evidence
+and backend health without running an expert or changing the visible screen. Pass `eventId` alone,
+or filters plus `limit` and the returned `cursor`. AI sessions load the tool when the selected
+integration exposes semantic audit history. Use `tui_get_table` to inspect the visible Audit screen.
+`r` refreshes the current audit page; `g` returns to the newest page. Repeated refreshes are coalesced.
diff --git a/docs/user-manual/modules/ROOT/pages/jbang-commands/camel-jbang-semantic-audit.adoc b/docs/user-manual/modules/ROOT/pages/jbang-commands/camel-jbang-semantic-audit.adoc
new file mode 100644
index 000000000000..b0eebeafe1bc
--- /dev/null
+++ b/docs/user-manual/modules/ROOT/pages/jbang-commands/camel-jbang-semantic-audit.adoc
@@ -0,0 +1,37 @@
+
+// AUTO-GENERATED by camel-package-maven-plugin - DO NOT EDIT THIS FILE
+= camel semantic audit
+
+Retrieve retained semantic audit records and linked evidence
+
+
+== Usage
+
+[source,bash]
+----
+camel semantic audit [options]
+----
+
+
+
+== Options
+
+[cols="2,5,1,2",options="header"]
+|===
+| Option | Description | Default | Type
+| `--action` | Filter by explicit route action, such as allow or block |  | String
+| `--category` | Filter by record category, such as evaluation, decision or request |  | String
+| `--correlation-id` | Filter by application correlation ID |  | String
+| `--cursor` | Opaque cursor for an older page; retain the original filters |  | String
+| `--event-id` | Retrieve one event and its linked evidence instead of a page |  | String
+| `--expert` | Filter by expert bean reference |  | String
+| `--json` | Output a single JSON document |  | boolean
+| `--limit` | Maximum records per page (1-200) | 50 | int
+| `--namespace` | Filter by application namespace |  | String
+| `--route-id` | Filter by route ID |  | String
+| `--since` | Earliest timestamp, inclusive, in ISO-8601 format with a UTC offset |  | String
+| `--timeout` | Timeout in milliseconds waiting for the integration | 60000 | long
+| `-h,--help` | Display the help and sub-commands |  | boolean
+|===
+
+
diff --git a/docs/user-manual/modules/ROOT/pages/jbang-commands/camel-jbang-semantic.adoc b/docs/user-manual/modules/ROOT/pages/jbang-commands/camel-jbang-semantic.adoc
index ddfdae7e4972..406dca6b701f 100644
--- a/docs/user-manual/modules/ROOT/pages/jbang-commands/camel-jbang-semantic.adoc
+++ b/docs/user-manual/modules/ROOT/pages/jbang-commands/camel-jbang-semantic.adoc
@@ -18,6 +18,7 @@ camel semantic [options]
 [cols="2,5",options="header"]
 |===
 | Subcommand | Description
+| xref:jbang-commands/camel-jbang-semantic-audit.adoc[audit] | Retrieve retained semantic audit records and linked evidence
 | xref:jbang-commands/camel-jbang-semantic-eval.adoc[eval] | Evaluate a semantic definition or expert operation
 | xref:jbang-commands/camel-jbang-semantic-get.adoc[get] | List semantic definitions and expert contracts
 |===
diff --git a/dsl/camel-cli-connector/src/main/java/org/apache/camel/cli/connector/LocalCliConnector.java b/dsl/camel-cli-connector/src/main/java/org/apache/camel/cli/connector/LocalCliConnector.java
index 2e0325483b3f..2d42add2b115 100644
--- a/dsl/camel-cli-connector/src/main/java/org/apache/camel/cli/connector/LocalCliConnector.java
+++ b/dsl/camel-cli-connector/src/main/java/org/apache/camel/cli/connector/LocalCliConnector.java
@@ -128,6 +128,7 @@ public class LocalCliConnector extends ServiceSupport
     private String mainClass;
     private volatile ExecutorService terminateExecutor;
     private ExecutorService semanticExecutor;
+    private ExecutorService auditExecutor;
     private final AtomicLong semanticConsoleLookup = new AtomicLong(System.nanoTime() - SEMANTIC_CONSOLE_RETRY_NANOS);
     private ProducerTemplate producer;
     private ConsumerTemplate consumer;
@@ -243,7 +244,8 @@ public class LocalCliConnector extends ServiceSupport
 
     @Override
     public CompletableFuture<Boolean> dispatchAsync(JsonObject root, CliActionOutput output) {
-        if (!"semantic-evaluate".equals(root.getString("action"))) {
+        boolean auditQuery = "semantic-audit".equals(root.getString("action"));
+        if (!auditQuery && !"semantic-evaluate".equals(root.getString("action"))) {
             return CliActionDispatcher.super.dispatchAsync(root, output);
         }
         CompletableFuture<Boolean> result = new CompletableFuture<>();
@@ -257,7 +259,7 @@ public class LocalCliConnector extends ServiceSupport
             }
             return null;
         });
-        result.orTimeout(55, TimeUnit.SECONDS).whenComplete((value, failure) -> {
+        result.orTimeout(auditQuery ? 8 : 55, TimeUnit.SECONDS).whenComplete((value, failure) -> {
             if (failure != null) {
                 task.cancel(true);
             }
@@ -267,21 +269,34 @@ public class LocalCliConnector extends ServiceSupport
                 if (isStoppingOrStopped()) {
                     throw new IllegalStateException("CLI connector is stopping or stopped");
                 }
-                if (semanticExecutor == null) {
-                    semanticExecutor = new ThreadPoolBuilder(camelContext).poolSize(2).maxPoolSize(2).maxQueueSize(0)
-                            .rejectedPolicy(ThreadPoolRejectedPolicy.Abort)
-                            .build("cli-semantic-evaluation", "CliSemanticEvaluation");
+                if (auditQuery) {
+                    if (auditExecutor == null) {
+                        auditExecutor = newSemanticExecutor("cli-semantic-audit", "CliSemanticAudit");
+                    }
+                    auditExecutor.execute(task);
+                } else {
+                    if (semanticExecutor == null) {
+                        semanticExecutor = newSemanticExecutor("cli-semantic-evaluation", "CliSemanticEvaluation");
+                    }
+                    semanticExecutor.execute(task);
                 }
-                semanticExecutor.execute(task);
             }
         } catch (RejectedExecutionException busy) {
-            result.completeExceptionally(new IllegalStateException("Busy: semantic evaluations are already running"));
+            result.completeExceptionally(new IllegalStateException(
+                    auditQuery
+                            ? "Busy: semantic audit queries are already running"
+                            : "Busy: semantic evaluations are already running"));
         } catch (Exception e) {
             result.completeExceptionally(e);
         }
         return result;
     }
 
+    private ExecutorService newSemanticExecutor(String source, String name) throws Exception {
+        return new ThreadPoolBuilder(camelContext).poolSize(2).maxPoolSize(2).maxQueueSize(0)
+                .rejectedPolicy(ThreadPoolRejectedPolicy.Abort).build(source, name);
+    }
+
     @Override
     public boolean dispatch(JsonObject root, CliActionOutput output) throws Exception {
         CliActionOutput prevOutput = this.actionOutput;
@@ -367,7 +382,8 @@ public class LocalCliConnector extends ServiceSupport
                 doActionJfrTask(root);
             } else if ("cli-debug".equals(action)) {
                 doActionCliDebug(root);
-            } else if ("semantic-metadata".equals(action) || "semantic-evaluate".equals(action)) {
+            } else if ("semantic-metadata".equals(action) || "semantic-evaluate".equals(action)
+                    || "semantic-audit".equals(action)) {
                 doActionSemanticTask(root);
             } else if ("spring-boot-configuration".equals(action)) {
                 doActionSpringBootConfigurationTask(root);
@@ -904,6 +920,9 @@ public class LocalCliConnector extends ServiceSupport
         Map<String, Object> options = new HashMap<>();
         List<String> keys = "semantic-metadata".equals(action)
                 ? List.of("expert", "overview")
+                : "semantic-audit".equals(action)
+                        ? List.of("eventId", "cursor", "limit", "since", "category", "expert", "routeId", "namespace",
+                                "correlationId")
                 : List.of("evaluation", "body", "headers", "variables", "expert", "operation", "input", "parameters",
                         "timeout");
         for (String key : keys) {
@@ -911,6 +930,9 @@ public class LocalCliConnector extends ServiceSupport
                 options.put(key, root.get(key));
             }
         }
+        if ("semantic-audit".equals(action) && root.containsKey("auditAction")) {
+            options.put("action", root.get("auditAction"));
+        }
         return dc == null ? new JsonObject() : (JsonObject) dc.call(DevConsole.MediaType.JSON, options);
     }
 
@@ -1927,6 +1949,10 @@ public class LocalCliConnector extends ServiceSupport
         ServiceHelper.stopService(transport);
         // Stop the transport before taking this monitor: file dispatch may hold it while the transport stops.
         synchronized (this) {
+            if (auditExecutor != null) {
+                camelContext.getExecutorServiceManager().shutdownNow(auditExecutor);
+                auditExecutor = null;
+            }
             if (semanticExecutor != null) {
                 camelContext.getExecutorServiceManager().shutdownNow(semanticExecutor);
                 semanticExecutor = null;
diff --git a/dsl/camel-cli-connector/src/test/java/org/apache/camel/cli/connector/LocalCliConnectorSemanticLifecycleTest.java b/dsl/camel-cli-connector/src/test/java/org/apache/camel/cli/connector/LocalCliConnectorSemanticLifecycleTest.java
index c8ba1664616f..efb4fb9e0afc 100644
--- a/dsl/camel-cli-connector/src/test/java/org/apache/camel/cli/connector/LocalCliConnectorSemanticLifecycleTest.java
+++ b/dsl/camel-cli-connector/src/test/java/org/apache/camel/cli/connector/LocalCliConnectorSemanticLifecycleTest.java
@@ -32,15 +32,17 @@ import org.apache.camel.spi.CliConnectorFactory;
 import org.apache.camel.spi.ThreadPoolProfile;
 import org.apache.camel.support.LifecycleStrategySupport;
 import org.apache.camel.util.json.JsonObject;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.awaitility.Awaitility.await;
 
 class LocalCliConnectorSemanticLifecycleTest {
-    @Test
-    void stopClosesAnExecutorWhoseCreationIsAlreadyInProgress() throws Exception {
+    @ParameterizedTest
+    @ValueSource(strings = { "semantic-evaluate", "semantic-audit" })
+    void stopClosesAnExecutorWhoseCreationIsAlreadyInProgress(String action) throws Exception {
         try (var context = new DefaultCamelContext()) {
             var created = new CountDownLatch(1);
             var release = new CountDownLatch(1);
@@ -61,7 +63,7 @@ class LocalCliConnectorSemanticLifecycleTest {
                 @Override
                 public ExecutorService newThreadPool(Object source, String name, ThreadPoolProfile profile) {
                     ExecutorService executor = super.newThreadPool(source, name, profile);
-                    if ("CliSemanticEvaluation".equals(name)) {
+                    if (("semantic-audit".equals(action) ? "CliSemanticAudit" : "CliSemanticEvaluation").equals(name)) {
                         pool.set(executor);
                         created.countDown();
                         try {
@@ -76,7 +78,7 @@ class LocalCliConnectorSemanticLifecycleTest {
             });
             var connector = startConnector(context);
             FutureTask<CompletableFuture<Boolean>> dispatch = new FutureTask<>(
-                    () -> connector.dispatchAsync(action(), ignored -> {
+                    () -> connector.dispatchAsync(action(action), ignored -> {
                     }));
             FutureTask<Void> stop = new FutureTask<>(() -> {
                 connector.stop();
@@ -110,12 +112,13 @@ class LocalCliConnectorSemanticLifecycleTest {
         }
     }
 
-    @Test
-    void evaluationCannotCreateAnExecutorAfterStop() throws Exception {
+    @ParameterizedTest
+    @ValueSource(strings = { "semantic-evaluate", "semantic-audit" })
+    void evaluationCannotCreateAnExecutorAfterStop(String action) throws Exception {
         try (var context = new DefaultCamelContext()) {
             var connector = startConnector(context);
             connector.stop();
-            CompletableFuture<Boolean> result = connector.dispatchAsync(action(), ignored -> {
+            CompletableFuture<Boolean> result = connector.dispatchAsync(action(action), ignored -> {
             });
             assertThatThrownBy(() -> result.get(5, TimeUnit.SECONDS))
                     .hasRootCauseInstanceOf(IllegalStateException.class)
@@ -123,8 +126,8 @@ class LocalCliConnectorSemanticLifecycleTest {
         }
     }
 
-    private static JsonObject action() {
-        return new JsonObject(Map.of("action", "semantic-evaluate"));
+    private static JsonObject action(String action) {
+        return new JsonObject(Map.of("action", action));
     }
 
     private static LocalCliConnector startConnector(DefaultCamelContext context) {
diff --git a/dsl/camel-jbang/camel-jbang-core/src/generated/resources/META-INF/camel-jbang-commands-metadata.json b/dsl/camel-jbang/camel-jbang-core/src/generated/resources/META-INF/camel-jbang-commands-metadata.json
index b89a9e4721d0..d8d9ded84d15 100644
--- a/dsl/camel-jbang/camel-jbang-core/src/generated/resources/META-INF/camel-jbang-commands-metadata.json
+++ b/dsl/camel-jbang/camel-jbang-core/src/generated/resources/META-INF/camel-jbang-commands-metadata.json
@@ -30,7 +30,7 @@
     { "name": "run", "fullName": "run", "description": "Run as local Camel integration", "sourceClass": "org.apache.camel.dsl.jbang.core.commands.Run", "options": [ { "names": "--background", "description": "Run in the background", "defaultValue": "false", "javaType": "boolean", "type": "boolean" }, { "names": "--background-wait", "description": "To wait for run in background to startup successfully, before returning", "defaultValue": "true", "javaType": "boolean", "type": "boolean" }, { [...]
     { "name": "sbom", "fullName": "sbom", "description": "Generate a CycloneDX or SPDX SBOM for a specific project", "sourceClass": "org.apache.camel.dsl.jbang.core.commands.SBOMGenerator", "options": [ { "names": "--build-property", "description": "Maven build properties, ex. --build-property=prop1=foo", "javaType": "java.util.List", "type": "array" }, { "names": "--camel-spring-boot-version", "description": "Camel version to use with Spring Boot", "javaType": "java.lang.String", "type" [...]
     { "name": "script", "fullName": "script", "description": "Run Camel integration as shell script for terminal scripting", "sourceClass": "org.apache.camel.dsl.jbang.core.commands.Script", "options": [ { "names": "--logging", "description": "Can be used to turn on logging (logs to file in <user home>\/.camel directory)", "defaultValue": "false", "javaType": "boolean", "type": "boolean" }, { "names": "--logging-level", "description": "Logging level (ERROR, WARN, INFO, DEBUG, TRACE)", "d [...]
-    { "name": "semantic", "fullName": "semantic", "description": "List semantic definitions and expert contracts", "sourceClass": "org.apache.camel.dsl.jbang.core.commands.action.CamelSemantic", "options": [ { "names": "--expert", "description": "Show the operations and parameter contract of this expert", "javaType": "java.lang.String", "type": "string" }, { "names": "--json", "description": "Output a single JSON document", "javaType": "boolean", "type": "boolean" }, { "names": "--timeou [...]
+    { "name": "semantic", "fullName": "semantic", "description": "List semantic definitions and expert contracts", "sourceClass": "org.apache.camel.dsl.jbang.core.commands.action.CamelSemantic", "options": [ { "names": "--expert", "description": "Show the operations and parameter contract of this expert", "javaType": "java.lang.String", "type": "string" }, { "names": "--json", "description": "Output a single JSON document", "javaType": "boolean", "type": "boolean" }, { "names": "--timeou [...]
     { "name": "shell", "fullName": "shell", "description": "Interactive Camel CLI shell.", "sourceClass": "org.apache.camel.dsl.jbang.core.commands.Shell", "options": [ { "names": "-h,--help", "description": "Display the help and sub-commands", "javaType": "boolean", "type": "boolean" } ] },
     { "name": "stop", "fullName": "stop", "description": "Shuts down running Camel integrations", "sourceClass": "org.apache.camel.dsl.jbang.core.commands.process.StopProcess", "options": [ { "names": "--kill", "description": "To force killing the process (SIGKILL)", "javaType": "boolean", "type": "boolean" }, { "names": "-h,--help", "description": "Display the help and sub-commands", "javaType": "boolean", "type": "boolean" } ] },
     { "name": "top", "fullName": "top", "description": "Top status of Camel integrations", "sourceClass": "org.apache.camel.dsl.jbang.core.commands.process.CamelTop", "options": [ { "names": "--watch", "description": "Execute periodically and showing output fullscreen", "javaType": "boolean", "type": "boolean" }, { "names": "-h,--help", "description": "Display the help and sub-commands", "javaType": "boolean", "type": "boolean" } ], "subcommands": [ { "name": "context", "fullName": "top  [...]
diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java
index 41b63bd7a972..b785c5e37d7b 100644
--- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java
+++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java
@@ -215,7 +215,8 @@ public class CamelJBangMain implements Callable<Integer> {
                 .addSubcommand("script", new CommandLine(new Script(this)))
                 .addSubcommand("semantic", new CommandLine(new CamelSemantic(this))
                         .addSubcommand("get", new CommandLine(new SemanticGet(this)))
-                        .addSubcommand("eval", new CommandLine(new SemanticEvaluate(this))))
+                        .addSubcommand("eval", new CommandLine(new SemanticEvaluate(this)))
+                        .addSubcommand("audit", new CommandLine(new SemanticAudit(this))))
                 .addSubcommand("shell", new CommandLine(new Shell(this)))
                 .addSubcommand("stop", new CommandLine(new StopProcess(this)))
                 .addSubcommand("top", new CommandLine(new CamelTop(this))
diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelSemantic.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelSemantic.java
index 8f6a22246022..235148202c20 100644
--- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelSemantic.java
+++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelSemantic.java
@@ -34,7 +34,8 @@ import picocli.CommandLine;
                              "%nExamples:",
                              "  camel semantic my-app",
                              "  camel semantic get my-app --expert=guard",
-                             "  camel semantic eval my-app --evaluation=safe --body='Sample message' --json" })
+                             "  camel semantic eval my-app --evaluation=safe --body='Sample message' --json",
+                             "  camel semantic audit my-app --category=decision --json" })
 public class CamelSemantic extends SemanticActionCommand {
 
     @CommandLine.Option(names = "--expert", description = "Show the operations and parameter contract of this expert")
diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/SemanticAudit.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/SemanticAudit.java
new file mode 100644
index 000000000000..feeac68567c8
--- /dev/null
+++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/SemanticAudit.java
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.dsl.jbang.core.commands.action;
+
+import java.time.Instant;
+import java.time.format.DateTimeParseException;
+import java.util.List;
+import java.util.stream.IntStream;
+
+import com.github.freva.asciitable.AsciiTable;
+import com.github.freva.asciitable.Column;
+import com.github.freva.asciitable.ColumnData;
+import com.github.freva.asciitable.HorizontalAlign;
+import org.apache.camel.dsl.jbang.core.commands.CamelJBangMain;
+import org.apache.camel.util.json.JsonArray;
+import org.apache.camel.util.json.JsonObject;
+import org.apache.camel.util.json.Jsoner;
+import picocli.CommandLine;
+
+@CommandLine.Command(name = "audit", description = "Retrieve retained semantic audit records and linked evidence",
+                     sortOptions = false, showDefaultValues = true,
+                     footer = {
+                             "%nExamples:",
+                             "  camel semantic audit my-app --category=decision --action=block",
+                             "  camel semantic audit my-app --expert=guard --limit=20 --json",
+                             "  camel semantic audit my-app --event-id=<event-id> --json" })
+public class SemanticAudit extends SemanticActionCommand {
+
+    @CommandLine.Option(names = "--event-id", description = "Retrieve one event and its linked evidence instead of a page")
+    String eventId;
+
+    @CommandLine.Option(names = "--category",
+                        description = "Filter by record category, such as evaluation, decision or request")
+    String category;
+
+    @CommandLine.Option(names = "--action", description = "Filter by explicit route action, such as allow or block")
+    String action;
+
+    @CommandLine.Option(names = "--expert", description = "Filter by expert bean reference")
+    String expert;
+
+    @CommandLine.Option(names = "--route-id", description = "Filter by route ID")
+    String routeId;
+
+    @CommandLine.Option(names = "--namespace", description = "Filter by application namespace")
+    String namespace;
+
+    @CommandLine.Option(names = "--correlation-id", description = "Filter by application correlation ID")
+    String correlationId;
+
+    @CommandLine.Option(names = "--since", description = "Earliest timestamp, inclusive, in ISO-8601 format with a UTC offset")
+    String since;
+
+    @CommandLine.Option(names = "--cursor", description = "Opaque cursor for an older page; retain the original filters")
+    String cursor;
+
+    @CommandLine.Option(names = "--limit", defaultValue = "50", description = "Maximum records per page (1-200)")
+    int limit = 50;
+
+    public SemanticAudit(CamelJBangMain main) {
+        super(main);
+    }
+
+    @Override
+    protected JsonObject request() {
+        if (limit < 1 || limit > 200) {
+            throw new IllegalArgumentException("--limit must be between 1 and 200");
+        }
+        JsonObject request = new JsonObject();
+        request.put("action", "semantic-audit");
+        option(request, "category", category, "--category", 256);
+        // The connector reserves action for dispatch and translates auditAction to the console's action filter.
+        option(request, "auditAction", action, "--action", 256);
+        option(request, "expert", expert, "--expert", 256);
+        option(request, "routeId", routeId, "--route-id", 256);
+        option(request, "namespace", namespace, "--namespace", 256);
+        option(request, "correlationId", correlationId, "--correlation-id", 256);
+        option(request, "cursor", cursor, "--cursor", 512);
+        if (since != null) {
+            try {
+                request.put("since", Instant.parse(since).toString());
+            } catch (DateTimeParseException e) {
+                throw new IllegalArgumentException("--since must be an ISO-8601 timestamp with a UTC offset", e);
+            }
+        }
+        if (eventId != null) {
+            if (request.size() > 1 || commandSpec.commandLine().getParseResult().hasMatchedOption("--limit")) {
+                throw new IllegalArgumentException("--event-id cannot be combined with filters, --cursor or --limit");
+            }
+            option(request, "eventId", eventId, "--event-id", 256);
+        } else {
+            request.put("limit", limit);
+        }
+        return request;
+    }
+
+    private static void option(JsonObject request, String key, String value, String name, int maximum) {
+        if (value != null) {
+            if (value.isBlank() || value.length() > maximum) {
+                throw new IllegalArgumentException(name + " must not be blank or exceed " + maximum + " characters");
+            }
+            request.put(key, value);
+        }
+    }
+
+    @Override
+    protected int printResponse(JsonObject response) {
+        if (response.containsKey("error")) {
+            return error(1, "Audit query failed", response);
+        }
+        if (eventId != null && response.get("record") == null) {
+            return error(3, "Audit event is unavailable: " + eventId, response);
+        }
+        if (Boolean.TRUE.equals(response.get("cursorExpired"))) {
+            return error(1, "Audit cursor expired; start again without --cursor", response);
+        }
+        return super.printResponse(response);
+    }
+
+    @Override
+    protected void render(JsonObject response) {
+        if (response.containsKey("error")) {
+            return;
+        }
+        JsonObject audit = response.getMap("audit");
+        if (audit != null) {
+            printer().println("Audit: " + audit.toJson());
+        }
+        if (eventId != null) {
+            Object record = response.get("record");
+            printer().println(record == null ? "Record unavailable." : Jsoner.prettyPrint(Jsoner.serialize(record)));
+            JsonArray evidence = response.getCollection("evidence");
+            if (evidence != null && !evidence.isEmpty()) {
+                printer().println("Evidence:");
+                printer().println(Jsoner.prettyPrint(evidence.toJson()));
+            }
+            return;
+        }
+        JsonArray values = response.getCollection("records");
+        if (values != null && !values.isEmpty()) {
+            List<JsonObject> rows = IntStream.range(0, values.size()).<JsonObject> mapToObj(values::getMap).toList();
+            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, List.of(
+                    column("EVENT ID", "eventId"), column("TIMESTAMP", "timestamp"), column("CATEGORY", "category"),
+                    column("ACTION", "action"), column("STATUS", "status"), column("EXPERT", "expert"),
+                    column("OPERATION", "operation"), column("TARGET", "target"), column("NAMESPACE", "namespace"),
+                    column("REASON CODE", "reasonCode"), column("CORRELATION ID", "correlationId"))));
+        } else if (!Boolean.TRUE.equals(response.get("cursorExpired"))) {
+            printer().println("No retained audit records match this query.");
+        }
+        if (response.containsKey("evicted")) {
+            printer().println("Evicted: " + response.get("evicted"));
+        }
+        if (response.get("nextCursor") != null) {
+            printer().println("Next cursor: " + response.get("nextCursor"));
+        }
+    }
+
+    private static ColumnData<JsonObject> column(String heading, String field) {
+        return new Column().header(heading).dataAlign(HorizontalAlign.LEFT)
+                .with((JsonObject row) -> row.get(field) == null ? "" : row.get(field).toString());
+    }
+}
diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/AppFeatures.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/AppFeatures.java
index 4a4d18ed7937..55b96ab30240 100644
--- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/AppFeatures.java
+++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/AppFeatures.java
@@ -92,6 +92,11 @@ public record AppFeatures(
         return new AppFeatures(List.of(), List.of(), false, false, List.of(), false, false, false, Map.of());
     }
 
+    /** Whether the runtime exposes semantic audit history, independently of capture being enabled. */
+    public boolean semanticAudit() {
+        return signals.containsKey("semantic-audit");
+    }
+
     /** Whether the integration serves HTTP: platform-http or Rest DSL endpoints. */
     public boolean httpServed() {
         return http != null;
@@ -239,6 +244,9 @@ public record AppFeatures(
                 consoles.add(id.toString());
             }
         }
+        if (consoles.contains("semantic-audit")) {
+            signals.put("semantic-audit", "available");
+        }
         boolean otel = consoles.contains("opentelemetry");
         boolean micrometer = consoles.contains("micrometer") || status.get("micrometer") instanceof Map;
         if (otel || consoles.contains("micrometer")) {
diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/ToolGroup.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/ToolGroup.java
index c6a0682ab641..63314dd8686d 100644
--- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/ToolGroup.java
+++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/ToolGroup.java
@@ -29,7 +29,9 @@ public enum ToolGroup {
     /** Circuit breakers. */
     RESILIENCE("resilience"),
     /** The HTTP endpoints the integration serves, and a request to them (CAMEL-25307). */
-    HTTP("http");
+    HTTP("http"),
+    /** Retained semantic evaluation and route-decision evidence. */
+    SEMANTIC("semantic");
 
     private final String id;
 
diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/ToolGroups.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/ToolGroups.java
index a4c789f77a5e..19090aa550bf 100644
--- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/ToolGroups.java
+++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/ai/ToolGroups.java
@@ -94,6 +94,9 @@ public final class ToolGroups {
         List<Group> groups = new ArrayList<>();
         for (ToolGroup group : groups(f)) {
             switch (group) {
+                case SEMANTIC -> groups.add(new Group(
+                        group, List.of(),
+                        "Semantic audit history is available through the Camel CLI: camel semantic audit."));
                 case SQL -> groups.add(new Group(
                         group,
                         List.of(SQL_TOOL, DATASOURCES_TOOL, SQL_TRACE_TOOL),
@@ -145,6 +148,9 @@ public final class ToolGroups {
         if (features.httpServed()) {
             groups.add(ToolGroup.HTTP);
         }
+        if (features.semanticAudit()) {
+            groups.add(ToolGroup.SEMANTIC);
+        }
         return groups;
     }
 
diff --git a/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/action/SemanticCommandTest.java b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/action/SemanticCommandTest.java
index b6329a9a869f..0dda78737cd6 100644
--- a/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/action/SemanticCommandTest.java
+++ b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/action/SemanticCommandTest.java
@@ -361,7 +361,7 @@ class SemanticCommandTest {
     }
 
     @Test
-    void mainRegistersBothCommandsAndFormatsParseErrorsAsJson() {
+    void mainRegistersSemanticCommandsAndFormatsParseErrorsAsJson() {
         CamelJBangMain main = new CamelJBangMain() {
             @Override
             public void postAddCommands(CommandLine command, String[] args) {
@@ -369,6 +369,7 @@ class SemanticCommandTest {
                 assertNotNull(semantic);
                 assertNotNull(semantic.getSubcommands().get("get"));
                 assertNotNull(semantic.getSubcommands().get("eval"));
+                assertNotNull(semantic.getSubcommands().get("audit"));
                 assertFalse(command.getSubcommands().get("get").getSubcommands().containsKey("semantic"));
                 assertFalse(command.getSubcommands().get("cmd").getSubcommands().containsKey("semantic-evaluate"));
             }
@@ -433,7 +434,7 @@ class SemanticCommandTest {
     }
 
     @ParameterizedTest
-    @ValueSource(strings = { "", "get", "eval" })
+    @ValueSource(strings = { "", "get", "eval", "audit" })
     void mainDispatchesSemanticGroupIncludingDefaultGet(String subcommand) throws Exception {
         AtomicInteger exitCode = new AtomicInteger(-1);
         CamelJBangMain main = new CamelJBangMain() {
@@ -461,10 +462,171 @@ class SemanticCommandTest {
             main.execute(args.toArray(String[]::new));
             return exitCode.get();
         }, request -> {
-            assertEquals("eval".equals(subcommand) ? "semantic-evaluate" : "semantic-metadata", request.get("action"));
-            return jsonUnchecked("{\"status\":\"success\",\"evaluations\":[]}");
+            String action = switch (subcommand) {
+                case "eval" -> "semantic-evaluate";
+                case "audit" -> "semantic-audit";
+                default -> "semantic-metadata";
+            };
+            assertEquals(action, request.get("action"));
+            return jsonUnchecked("audit".equals(subcommand)
+                    ? "{\"audit\":{\"reader\":\"memory\"},\"records\":[]}"
+                    : "{\"status\":\"success\",\"evaluations\":[]}");
         }));
-        assertEquals("success", json(printer.getOutput()).get("status"));
+        if ("audit".equals(subcommand)) {
+            assertEquals("memory", json(printer.getOutput()).getMap("audit").get("reader"));
+        } else {
+            assertEquals("success", json(printer.getOutput()).get("status"));
+        }
+    }
+
+    @Test
+    void auditTableIncludesEventIdentityAndKeepsDecisionsSeparateFromEvaluationStatus() throws Exception {
+        assertEquals(0, respond(new SemanticAudit(main()), request -> {
+            assertEquals("semantic-audit", request.get("action"));
+            assertEquals(50L, request.getLong("limit"));
+            assertEquals(2, request.size());
+            return jsonUnchecked("""
+                    {"audit":{"reader":"memory","enabled":true,"dropped":2},
+                     "records":[{"eventId":"decision-1","timestamp":"2026-10-10T08:00:00Z",
+                       "category":"decision","action":"block","operation":"tools/call","target":"support-request",
+                       "namespace":"test","reasonCode":"policy_denied","correlationId":"request-123"},
+                       {"eventId":"evaluation-1","timestamp":"2026-10-10T07:59:59Z","category":"evaluation",
+                        "expert":"guard","status":"success","result":{"value":false}}],
+                     "nextCursor":"opaque:cursor","evicted":7,"cursorExpired":false}
+                    """);
+        }));
+        for (String value : List.of("EVENT ID", "TIMESTAMP", "ACTION", "STATUS", "decision-1", "evaluation-1",
+                "block", "success", "guard", "tools/call", "support-request", "policy_denied", "request-123",
+                "Next cursor: opaque:cursor", "Evicted: 7", "\"dropped\":2")) {
+            assertTrue(printer.getOutput().contains(value), printer.getOutput());
+        }
+        assertFalse(printer.getOutput().contains("allow"));
+        assertEquals("", errors.toString());
+    }
+
+    @Test
+    void auditFiltersKeepTheDispatchActionAndPreserveTheJsonPage() throws Exception {
+        JsonObject page = json("""
+                {"audit":{"reader":"custom"},"records":[],"nextCursor":"next-page","evicted":3,"cursorExpired":false}
+                """);
+        assertEquals(0, respond(new SemanticAudit(main()), request -> {
+            assertEquals("semantic-audit", request.get("action"));
+            assertEquals("block", request.get("auditAction"));
+            assertEquals("decision", request.get("category"));
+            assertEquals("guard", request.get("expert"));
+            assertEquals("route-1", request.get("routeId"));
+            assertEquals("test", request.get("namespace"));
+            assertEquals("correlation=123", request.get("correlationId"));
+            assertEquals("2026-10-10T08:00:00Z", request.get("since"));
+            assertEquals("opaque=cursor", request.get("cursor"));
+            assertEquals(20L, request.getLong("limit"));
+            return page;
+        }, "--category=decision", "--action=block", "--expert=guard", "--route-id=route-1", "--namespace=test",
+                "--correlation-id=correlation=123", "--since=2026-10-10T10:00:00+02:00", "--cursor=opaque=cursor",
+                "--limit=20", "--json"));
+        assertEquals(page, json(printer.getOutput()));
+        assertEquals("", errors.toString());
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = { false, true })
+    void auditEventIncludesHistoricalEvidenceAndUnavailableReferences(boolean jsonOutput) throws Exception {
+        JsonObject response = json("""
+                {"audit":{"reader":"memory","enabled":false},
+                 "record":{"eventId":"decision-1","category":"decision","action":"block",
+                           "evidence":["evaluation-1","evicted-1"]},
+                 "evidence":[{"eventId":"evaluation-1","provider":"safety-provider","model":"guard-v1","revision":"r1",
+                              "result":{"value":false},"semantics":{"meaning":"Injection detected"}},
+                             {"eventId":"evicted-1","unavailable":true}]}
+                """);
+        assertEquals(0, respond(new SemanticAudit(main()), request -> {
+            assertEquals("semantic-audit", request.get("action"));
+            assertEquals("decision-1", request.get("eventId"));
+            assertEquals(2, request.size());
+            return response;
+        }, "--event-id=decision-1", "--json=" + jsonOutput));
+        if (jsonOutput) {
+            assertEquals(response, json(printer.getOutput()));
+        } else {
+            for (String value : List.of("decision-1", "Evidence:", "evaluation-1", "safety-provider", "guard-v1",
+                    "Injection detected", "evicted-1", "\"unavailable\": true")) {
+                assertTrue(printer.getOutput().contains(value), printer.getOutput());
+            }
+        }
+        assertEquals("", errors.toString());
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = { 1, 200 })
+    void auditAcceptsPageLimitBoundsAndEmptyHistory(int limit) throws Exception {
+        assertEquals(0, respond(new SemanticAudit(main()), request -> {
+            assertEquals((long) limit, request.getLong("limit"));
+            return jsonUnchecked("""
+                    {"audit":{"enabled":false,"reader":"memory"},"records":[],"evicted":0,"cursorExpired":false}
+                    """);
+        }, "--limit=" + limit));
+        assertTrue(printer.getOutput().contains("No retained audit records match this query."));
+        assertEquals("", errors.toString());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "--limit=0", "--limit=201", "--limit=not-a-number", "--since=yesterday", "--expert=",
+            "--category=", "--action=", "--namespace=", "--correlation-id=", "--route-id=", "--cursor=", "--event-id=" })
+    void auditRejectsInvalidArgumentsBeforeSendingARequest(String option) throws Exception {
+        assertEquals(2, command(new SemanticAudit(main())).execute(Long.toString(pid), option, "--json"));
+        assertError(2, "");
+        assertTrue(actionFiles().isEmpty());
+    }
+
+    @ParameterizedTest
+    @CsvSource({ "--expert,257", "--cursor,513", "--event-id,257" })
+    void auditRejectsOversizedIdentifiersBeforeSendingARequest(String option, int length) throws Exception {
+        assertEquals(2, command(new SemanticAudit(main())).execute(Long.toString(pid),
+                option + "=" + "x".repeat(length), "--json"));
+        assertError(2, option);
+        assertTrue(actionFiles().isEmpty());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "--expert=guard", "--action=block", "--since=2026-10-10T08:00:00Z", "--cursor=older",
+            "--limit=50" })
+    void auditEventLookupRejectsIgnoredQueryOptions(String option) throws Exception {
+        assertEquals(2, command(new SemanticAudit(main())).execute(Long.toString(pid), "--event-id=decision-1",
+                option, "--json"));
+        assertError(2, "cannot be combined");
+        assertTrue(actionFiles().isEmpty());
+    }
+
+    @Test
+    void auditQueryFailureHasNonzeroExitAndKeepsTheStableErrorCode() throws Exception {
+        assertEquals(1, respond(new SemanticAudit(main()), request -> jsonUnchecked("""
+                {"audit":{"reader":"remote"},"error":"audit_query_failed"}
+                """), "--json"));
+        assertError(1, "Audit query failed");
+        assertEquals("audit_query_failed", json(printer.getOutput()).get("error"));
+        assertEquals("remote", json(printer.getOutput()).getMap("audit").get("reader"));
+    }
+
+    @Test
+    void auditUnavailableEventRetainsItsResponseWithNotFoundExitCode() throws Exception {
+        assertEquals(3, respond(new SemanticAudit(main()), request -> jsonUnchecked("""
+                {"audit":{"reader":"memory"},"record":null,"evidence":[]}
+                """), "--event-id=missing-event", "--json"));
+        assertError(3, "missing-event");
+        assertTrue(json(printer.getOutput()).containsKey("record"));
+        assertTrue(json(printer.getOutput()).getCollection("evidence").isEmpty());
+    }
+
+    @Test
+    void auditExpiredCursorIsAnExplicitFailureWithRetentionDetails() throws Exception {
+        assertEquals(1, respond(new SemanticAudit(main()), request -> jsonUnchecked("""
+                {"audit":{"reader":"memory"},"records":[],"cursorExpired":true,"evicted":9}
+                """), "--cursor=old-page", "--json"));
+        assertError(1, "cursor expired");
+        assertEquals(true, json(printer.getOutput()).get("cursorExpired"));
+        assertEquals(9L, json(printer.getOutput()).getLong("evicted"));
     }
 
     private void writeVersion(String version) throws Exception {
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanel.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanel.java
index 123292168428..a5cb703aa530 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanel.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanel.java
@@ -3365,12 +3365,9 @@ class AiPanel {
      * or the selected one reloaded (the groups then only grow: what it had before still counts), so the tools and the
      * prompt stay the same from question to question and a local model's prompt cache keeps working. While an
      * integration has no groups yet its status is read again, since one that just started may not have written it
-     * completely. The full set is not affected.
+     * completely. Full mode also uses these features to discover semantic audit history.
      */
     private void refreshToolGroups() {
-        if (!useCoreTools()) {
-            return;
-        }
         AppStatusSource source = appStatusSource != null ? appStatusSource : facadeStatusSource();
         String pid = source != null ? source.selectedPid() : null;
         int reloads = source != null ? source.reloadCount() : 0;
@@ -3445,7 +3442,9 @@ class AiPanel {
             return "no tools available";
         }
         int total = toolRegistry.getToolDefinitions().size();
-        int active = useCoreTools() ? toolRegistry.getCoreToolDefinitions(toolGroups.tools()).size() : total;
+        int active = useCoreTools()
+                ? toolRegistry.getCoreToolDefinitions(toolGroups.tools()).size()
+                : toolRegistry.getAvailableToolDefinitions(toolGroups.tools()).size();
         String mode = toolMode == null ? TOOL_MODE_AUTO : toolMode;
         String detail = TOOL_MODE_AUTO.equals(mode)
                 ? (useCoreTools() ? " (local provider)" : " (hosted provider)") : "";
@@ -3465,7 +3464,8 @@ class AiPanel {
         }
         List<LlmClient.ToolDef> defs = new ArrayList<>();
         List<TuiToolRegistry.ToolDef> source = useCoreTools()
-                ? toolRegistry.getCoreToolDefinitions(toolGroups.tools()) : toolRegistry.getToolDefinitions();
+                ? toolRegistry.getCoreToolDefinitions(toolGroups.tools())
+                : toolRegistry.getAvailableToolDefinitions(toolGroups.tools());
         for (TuiToolRegistry.ToolDef td : source) {
             defs.add(new LlmClient.ToolDef(td.name(), td.description(), td.inputSchema()));
         }
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/McpFacade.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/McpFacade.java
index 9a7205e24cbe..b67263863ab4 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/McpFacade.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/McpFacade.java
@@ -1034,6 +1034,13 @@ class McpFacade {
         return tabRegistry.historyTab().toggleDisplaySection(section, enabled);
     }
 
+    /** Query the selected runtime without changing tabs, drafts, filters or the selected audit record. */
+    JsonObject queryAudit(JsonObject request) {
+        IntegrationInfo selected = ctx == null ? null : ctx.findSelectedIntegration();
+        String pid = selected == null ? null : selected.phantom ? selected.linkedPid : selected.pid;
+        return pid == null ? null : ctx.executeIndependentAction(pid, request, 10000);
+    }
+
     // ---- Integration data ----
 
     JsonObject getReadme(String name) {
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticAuditView.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticAuditView.java
new file mode 100644
index 000000000000..bc5e9cfad44b
--- /dev/null
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticAuditView.java
@@ -0,0 +1,550 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.dsl.jbang.core.commands.tui;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+import dev.tamboui.layout.Constraint;
+import dev.tamboui.layout.Layout;
+import dev.tamboui.layout.Rect;
+import dev.tamboui.style.Style;
+import dev.tamboui.terminal.Frame;
+import dev.tamboui.text.Line;
+import dev.tamboui.text.Span;
+import dev.tamboui.tui.event.KeyCode;
+import dev.tamboui.tui.event.KeyEvent;
+import dev.tamboui.widgets.block.Block;
+import dev.tamboui.widgets.block.BorderType;
+import dev.tamboui.widgets.block.Borders;
+import dev.tamboui.widgets.input.TextInputState;
+import dev.tamboui.widgets.paragraph.Paragraph;
+import dev.tamboui.widgets.table.Row;
+import dev.tamboui.widgets.table.Table;
+import dev.tamboui.widgets.table.TableState;
+import org.apache.camel.util.json.JsonObject;
+
+import static org.apache.camel.dsl.jbang.core.commands.tui.SemanticDetails.text;
+import static org.apache.camel.dsl.jbang.core.commands.tui.TuiHelper.hint;
+
+/** Audit browsing owns its state independently of live definitions and inference drafts. */
+final class SemanticAuditView {
+    private static final Set<String> FILTERS
+            = Set.of("category", "action", "expert", "routeId", "namespace", "correlationId", "since");
+    private final MonitorContext context;
+    private final TableState selection = new TableState();
+    private String pid;
+    private String filter = "";
+    private Map<String, String> filters = Map.of();
+    private TextInputState input;
+    private JsonObject page;
+    private JsonObject details;
+    private CompletableFuture<JsonObject> pending;
+    private CompletableFuture<JsonObject> pendingDetails;
+    private JsonObject requestedQuery;
+    private JsonObject queuedQuery;
+    private String cursor;
+    private String requestedDetail;
+    private String queuedDetail;
+    private String selectedId;
+    private String error;
+    private int scroll;
+    private boolean detailFocused;
+
+    SemanticAuditView(MonitorContext context) {
+        this.context = context;
+    }
+
+    void reset() {
+        if (pending != null) {
+            pending.cancel(true);
+        }
+        if (pendingDetails != null) {
+            pendingDetails.cancel(true);
+        }
+        pid = null;
+        pending = null;
+        pendingDetails = null;
+        requestedQuery = null;
+        queuedQuery = null;
+        cursor = null;
+        requestedDetail = null;
+        queuedDetail = null;
+        page = null;
+        details = null;
+        selectedId = null;
+        error = null;
+        input = null;
+        filter = "";
+        filters = Map.of();
+        scroll = 0;
+        detailFocused = false;
+        selection.clearSelection();
+    }
+
+    private String currentPid() {
+        IntegrationInfo info = context.findSelectedIntegration();
+        return info == null ? null : info.phantom ? info.linkedPid : info.pid;
+    }
+
+    void load() {
+        query(null);
+    }
+
+    private void query(String cursor) {
+        String selected = currentPid();
+        if (!Objects.equals(pid, selected)) {
+            reset();
+            pid = selected;
+        }
+        if (pid == null) {
+            error = "Select a connected integration to browse audit history.";
+            return;
+        }
+        JsonObject request = new JsonObject(filters);
+        request.put("action", "semantic-audit");
+        request.put("limit", 50);
+        // The connector action and the decision-action filter use different transport names.
+        if (filters.containsKey("action")) {
+            request.put("auditAction", filters.get("action"));
+        }
+        if (cursor != null) {
+            request.put("cursor", cursor);
+        }
+        error = null;
+        if (pending != null) {
+            queuedQuery = request.equals(requestedQuery) ? null : request;
+        } else {
+            startQuery(request);
+        }
+    }
+
+    private void startQuery(JsonObject request) {
+        requestedQuery = request;
+        cursor = request.getString("cursor");
+        pending = execute(request);
+    }
+
+    private CompletableFuture<JsonObject> execute(JsonObject request) {
+        String target = pid;
+        return CompletableFuture
+                .supplyAsync(() -> context.executeIndependentAction(target, request, 10000), context.backgroundExecutor)
+                .exceptionally(failure -> new JsonObject(Map.of("error", "audit_query_failed")));
+    }
+
+    void refresh() {
+        if (pending != null && pending.isDone()) {
+            JsonObject response = pending.getNow(null);
+            pending = null;
+            if (queuedQuery != null) {
+                JsonObject next = queuedQuery;
+                queuedQuery = null;
+                startQuery(next);
+                return;
+            }
+            if (response == null || response.containsKey("error") || !response.containsKey("records")) {
+                error = response != null && response.containsKey("error")
+                        ? response.getString("error") : "Audit history is unavailable or disconnected.";
+            } else {
+                page = response;
+                error = null;
+                List<JsonObject> rows = rows();
+                int index = -1;
+                for (int i = 0; i < rows.size(); i++) {
+                    if (Objects.equals(selectedId, rows.get(i).getString("eventId"))) {
+                        index = i;
+                        break;
+                    }
+                }
+                if (index < 0 && selectedId == null && !rows.isEmpty()) {
+                    index = 0;
+                }
+                if (index < 0) {
+                    selection.clearSelection();
+                    if (selectedId != null) {
+                        select(selectedId);
+                    } else {
+                        details = null;
+                    }
+                } else {
+                    selection.select(index);
+                    select(rows.get(index).getString("eventId"));
+                }
+            }
+        }
+        if (pendingDetails != null && pendingDetails.isDone()) {
+            JsonObject response = pendingDetails.getNow(null);
+            pendingDetails = null;
+            if (Objects.equals(requestedDetail, selectedId)) {
+                if (response != null && !response.containsKey("error")) {
+                    details = response;
+                } else {
+                    error = "Selected audit details are unavailable.";
+                }
+            }
+            if (queuedDetail != null) {
+                String next = queuedDetail;
+                queuedDetail = null;
+                startDetails(next);
+            }
+        }
+    }
+
+    boolean ensureLoaded() {
+        refresh();
+        if (page == null && pending == null && error == null) {
+            load();
+        }
+        return pending != null || selectedId != null && pendingDetails != null;
+    }
+
+    String error() {
+        refresh();
+        return error;
+    }
+
+    List<JsonObject> rows() {
+        return SemanticTab.objects(page, "records");
+    }
+
+    private JsonObject selected() {
+        if (details != null && details.get("record") instanceof JsonObject record) {
+            return record;
+        }
+        return rows().stream().filter(r -> Objects.equals(selectedId, r.getString("eventId"))).findFirst().orElse(null);
+    }
+
+    void select(String id) {
+        if (pid == null) {
+            error = "Select a connected integration.";
+            return;
+        }
+        selectedId = id;
+        details = null;
+        scroll = 0;
+        if (pendingDetails != null) {
+            queuedDetail = id.equals(requestedDetail) ? null : id;
+        } else {
+            startDetails(id);
+        }
+    }
+
+    private void startDetails(String id) {
+        requestedDetail = id;
+        JsonObject request = new JsonObject(Map.of("action", "semantic-audit", "eventId", id));
+        pendingDetails = execute(request);
+    }
+
+    void navigate(int delta) {
+        refresh();
+        if (detailFocused) {
+            scroll = Math.max(0, scroll + delta);
+            return;
+        }
+        if (rows().isEmpty()) {
+            return;
+        }
+        int index = selection.selected() == null ? 0 : selection.selected();
+        selection.select(Math.max(0, Math.min(rows().size() - 1, index + delta)));
+        select(rows().get(selection.selected()).getString("eventId"));
+    }
+
+    boolean setFilter(String text) {
+        if (!Objects.equals(pid, currentPid())) {
+            reset();
+            pid = currentPid();
+        }
+        Map<String, String> parsed = new LinkedHashMap<>();
+        if (!text.isBlank()) {
+            for (String token : text.trim().split("\\s+")) {
+                String[] pair = token.split("=", 2);
+                if (pair.length != 2 || !FILTERS.contains(pair[0]) || pair[1].isBlank() || pair[1].length() > 256) {
+                    error = "Use field=value filters: category action expert routeId namespace correlationId since";
+                    return false;
+                }
+                if ("since".equals(pair[0])) {
+                    try {
+                        Instant.parse(pair[1]);
+                    } catch (Exception e) {
+                        error = "since requires a UTC ISO-8601 timestamp";
+                        return false;
+                    }
+                }
+                parsed.put(pair[0], pair[1]);
+            }
+        }
+        queuedDetail = null;
+        filters = Map.copyOf(parsed);
+        filter = text;
+        selection.clearSelection();
+        selectedId = null;
+        details = null;
+        page = null;
+        query(null);
+        return true;
+    }
+
+    boolean setInput(String field, String value) {
+        if ("audit.filter".equals(field)) {
+            return setFilter(value);
+        }
+        if ("audit.eventId".equals(field) && !value.isBlank() && value.length() <= 256) {
+            select(value);
+            return true;
+        }
+        if ("audit.page".equals(field)) {
+            if ("latest".equals(value)) {
+                query(null);
+                return true;
+            }
+            if ("older".equals(value) && page != null && page.getString("nextCursor") != null) {
+                query(page.getString("nextCursor"));
+                return true;
+            }
+        }
+        return false;
+    }
+
+    boolean inputActive() {
+        return input != null;
+    }
+
+    void paste(String value) {
+        if (input != null) {
+            FormHelper.handlePaste(value, input);
+        }
+    }
+
+    boolean escape() {
+        if (input != null) {
+            input = null;
+            return true;
+        }
+        if (detailFocused) {
+            detailFocused = false;
+            return true;
+        }
+        if (!filter.isEmpty()) {
+            setFilter("");
+            return true;
+        }
+        return false;
+    }
+
+    boolean key(KeyEvent key) {
+        refresh();
+        if (input != null) {
+            if (key.isCancel()) {
+                input = null;
+            } else if (key.isConfirm()) {
+                if (setFilter(input.text())) {
+                    input = null;
+                }
+            } else {
+                FormHelper.handleTextInput(key, input);
+            }
+            return true;
+        }
+        if (key.isChar('/')) {
+            input = new TextInputState(filter);
+            return true;
+        }
+        if (key.isChar('r')) {
+            query(queuedQuery == null ? cursor : queuedQuery.getString("cursor"));
+            return true;
+        }
+        if (key.isChar('n')) {
+            setInput("audit.page", "older");
+            return true;
+        }
+        if (key.isChar('g')) {
+            query(null);
+            return true;
+        }
+        if (key.isKey(KeyCode.TAB) || key.isConfirm()) {
+            detailFocused = !detailFocused;
+            return true;
+        }
+        if (key.isUp() || key.isDown() || key.isPageUp() || key.isPageDown()) {
+            navigate((key.isUp() || key.isPageUp() ? -1 : 1) * (key.isPageUp() || key.isPageDown() ? 10 : 1));
+            return true;
+        }
+        return false;
+    }
+
+    boolean detailFocused() {
+        return detailFocused;
+    }
+
+    SelectionContext selectionContext() {
+        return new SelectionContext(
+                "table", rows().stream().map(r -> r.getString("eventId")).toList(),
+                selection.selected() == null ? -1 : selection.selected(), rows().size(), "Semantic Audit");
+    }
+
+    JsonObject snapshot() {
+        refresh();
+        JsonObject state = new JsonObject();
+        state.put("tab", "Semantic");
+        state.put("view", "Audit");
+        state.put("rows", rows());
+        state.put("totalRows", rows().size());
+        state.put("selectedIndex", selection.selected());
+        state.put("selectedEventId", selectedId);
+        state.put("selectedRecord", selected());
+        state.put("evidence", SemanticTab.objects(details, "evidence"));
+        state.put("filters", filters);
+        state.put("filter", filter);
+        state.put("pending", pending != null || pendingDetails != null);
+        state.put("connected", currentPid() != null && Objects.equals(pid, currentPid()));
+        state.put("error", error);
+        state.put("focusedPane", detailFocused ? "detail" : "list");
+        for (String key : List.of("audit", "nextCursor", "evicted", "cursorExpired")) {
+            state.put(key, page == null ? null : page.get(key));
+        }
+        return state;
+    }
+
+    void render(Frame frame, Rect area) {
+        refresh();
+        List<Rect> panels
+                = Layout.vertical().constraints(Constraint.length(3), Constraint.percentage(42), Constraint.fill()).split(area);
+        JsonObject status = page == null ? null : page.getJsonObject("audit");
+        String statusLine = status == null
+                ? "Audit history" : "Master: " + status.get("enabled") + "   Experts: " + status.get("experts")
+                                    + "   OpenTelemetry: " + status.get("openTelemetry") + "   Reader: " + status.get("reader")
+                                    + "   Dropped: " + status.get("dropped") + "   Sink errors: " + status.get("sinkErrors");
+        String note = error != null ? error : pending != null ? "Loading..."
+                : "Evicted: " + (page == null ? 0 : page.get("evicted"))
+                  + (page != null && Boolean.TRUE.equals(page.get("cursorExpired"))
+                          ? "   Older cursor expired; refresh for retained history." : "")
+                  + (filter.isBlank() ? "" : "   " + filter);
+        frame.renderWidget(Paragraph.builder().text(statusLine + "\n" + note).build(), panels.get(0));
+        boolean wide = area.width() >= 140;
+        List<Row> content = new ArrayList<>();
+        for (JsonObject row : rows()) {
+            String timestamp = text(row, "timestamp");
+            String time = timestamp.length() > 23 ? timestamp.substring(11, 23) + "Z" : timestamp;
+            content.add(wide
+                    ? Row.from(time, text(row, "action"), text(row, "category"), text(row, "operation"), text(row, "target"),
+                            text(row, "namespace"), text(row, "reasonCode"), text(row, "correlationId"))
+                    : Row.from(time, text(row, "action"), text(row, "category"), text(row, "expert"), text(row, "reasonCode")));
+        }
+        Block tableBlock = block("Audit history [" + rows().size() + "]", !detailFocused);
+        if (content.isEmpty()) {
+            frame.renderWidget(Paragraph.builder().text("No retained records match this query. Capture may be disabled.")
+                    .block(tableBlock).build(), panels.get(1));
+        } else {
+            Table table = Table.builder().rows(content)
+                    .header((wide
+                            ? Row.from("TIMESTAMP", "ACTION", "CATEGORY", "OPERATION", "TARGET", "NAMESPACE", "REASON CODE",
+                                    "CORRELATION")
+                            : Row.from("TIMESTAMP", "ACTION", "CATEGORY", "EXPERT", "REASON CODE")).style(Theme.label()))
+                    .widths(wide
+                            ? List.of(Constraint.length(14), Constraint.length(8), Constraint.length(11), Constraint.length(13),
+                                    Constraint.percentage(15), Constraint.percentage(10), Constraint.fill(),
+                                    Constraint.length(13))
+                            : List.of(Constraint.length(14), Constraint.length(8), Constraint.length(11),
+                                    Constraint.percentage(20), Constraint.fill()))
+                    .block(tableBlock).highlightSymbol("› ").highlightStyle(Theme.selectionBg()).build();
+            frame.renderStatefulWidget(table, panels.get(1), selection);
+        }
+        List<Line> lines = new ArrayList<>();
+        JsonObject record = selected();
+        if (record == null) {
+            lines.add(Line.from("Select an audit record."));
+        } else {
+            for (String key : List.of("eventId", "category", "timestamp", "action", "operation", "target", "namespace",
+                    "reasonCode", "correlationId", "policyId", "policyVersion", "rule", "expert", "definition", "origin",
+                    "routeId", "invocationId", "batchId", "status")) {
+                if (record.get(key) != null) {
+                    lines.add(Line.from(Span.styled(key + "  ", Theme.label()), Span.raw(String.valueOf(record.get(key)))));
+                }
+            }
+            resultLines(lines, record);
+            for (JsonObject linked : SemanticTab.objects(details, "evidence")) {
+                lines.add(Line.empty());
+                lines.add(Line.from(Span.styled("Evidence: " + text(linked, "eventId"), Style.EMPTY.fg(Theme.accent()))));
+                if (Boolean.TRUE.equals(linked.get("unavailable"))) {
+                    lines.add(Line.from("Unavailable in this backend (disabled, evicted, or not delivered)."));
+                } else {
+                    lines.add(Line
+                            .from(text(linked, "expert") + " / " + text(linked, "operation") + " · " + text(linked, "status")));
+                    resultLines(lines, linked);
+                }
+            }
+            lines.add(Line.empty());
+            lines.add(Line.from("Input, headers, arbitrary metadata and submitted score descriptions are omitted."));
+        }
+        Block detailsBlock = block("Record details", detailFocused);
+        frame.renderWidget(detailsBlock, panels.get(2));
+        SemanticDetails.paragraph(frame, detailsBlock.inner(panels.get(2)), lines, scroll);
+    }
+
+    private static void resultLines(List<Line> lines, JsonObject record) {
+        for (String key : List.of("startedAt", "provider", "model", "revision")) {
+            if (record.get(key) != null) {
+                lines.add(Line.from(Span.styled(key + "  ", Theme.label()), Span.raw(String.valueOf(record.get(key)))));
+            }
+        }
+        if (record.get("resultOmitted") != null) {
+            lines.add(Line.from("Result unavailable: " + text(record, "resultOmitted")));
+        }
+        if (!(record.get("result") instanceof JsonObject result)) {
+            return;
+        }
+        JsonObject response = new JsonObject(result);
+        response.put("status", "success");
+        response.put("elapsedMillis", record.get("durationNanos") instanceof Number n ? n.longValue() / 1000000 : 0);
+        JsonObject semantics = record.getJsonObject("semantics");
+        JsonObject contract = new JsonObject();
+        if (semantics != null) {
+            contract.put("resultMeaning", semantics.get("meaning"));
+            contract.put("probabilityMeaning", semantics.get("probabilityMeaning"));
+        }
+        JsonObject operation = new JsonObject();
+        operation.put("contract", contract);
+        operation.put("resultType", semantics == null ? "" : semantics.get("resultType"));
+        lines.addAll(SemanticResultView.lines(response, operation, List.of()));
+    }
+
+    private static Block block(String title, boolean focused) {
+        return Block.builder().title(title).borders(Borders.ALL).borderType(BorderType.ROUNDED)
+                .borderStyle(focused ? Style.EMPTY.fg(Theme.accent()) : Theme.border()).build();
+    }
+
+    void footer(List<Span> spans) {
+        if (input != null) {
+            spans.add(Span.raw(" /" + input.text() + "█  "));
+            hint(spans, "Enter", "apply");
+            hint(spans, "Esc", "cancel");
+        } else {
+            hint(spans, "v", "view");
+            hint(spans, "/", "filter");
+            hint(spans, "Tab", "pane");
+            hint(spans, "n", "older");
+            hint(spans, "g", "latest");
+            hint(spans, "r", "refresh");
+        }
+    }
+}
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticTab.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticTab.java
index 5dd426b2e4a4..5e94dc322de8 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticTab.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticTab.java
@@ -52,12 +52,13 @@ import org.apache.camel.util.json.JsonObject;
 import static org.apache.camel.dsl.jbang.core.commands.tui.SemanticDetails.text;
 import static org.apache.camel.dsl.jbang.core.commands.tui.TuiHelper.*;
 
-/** Three views of the same published semantic definitions and expert contracts. */
+/** Semantic definitions, expert contracts, relationships and retained audit evidence. */
 class SemanticTab extends AbstractTableTab {
     private enum View {
         DEFINITIONS("Definitions"),
         EXPERTS("Experts"),
-        RELATIONSHIPS("Relationships");
+        RELATIONSHIPS("Relationships"),
+        AUDIT("Audit");
 
         final String label;
 
@@ -73,6 +74,7 @@ class SemanticTab extends AbstractTableTab {
         PLAYGROUND
     }
 
+    private final SemanticAuditView audit;
     private JsonObject data;
     private CompletableFuture<JsonObject> pending;
     private String pid;
@@ -104,6 +106,7 @@ class SemanticTab extends AbstractTableTab {
 
     SemanticTab(MonitorContext ctx) {
         super(ctx);
+        audit = new SemanticAuditView(ctx);
     }
 
     @Override
@@ -113,6 +116,7 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public void onIntegrationChanged() {
+        audit.reset();
         data = null;
         pending = null;
         pid = null;
@@ -137,6 +141,10 @@ class SemanticTab extends AbstractTableTab {
     }
 
     private void load() {
+        if (view == View.AUDIT) {
+            audit.load();
+            return;
+        }
         IntegrationInfo info = ctx.findSelectedIntegration();
         String selected = info == null ? null : info.phantom ? info.linkedPid : info.pid;
         if (selected == null && data != null && Objects.equals(selectionId, ctx.selectedPid)) {
@@ -189,6 +197,9 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public boolean ensureDataLoaded() {
+        if (view == View.AUDIT) {
+            return audit.ensureLoaded();
+        }
         refresh();
         if (data == null && pending == null && error == null) {
             load();
@@ -198,6 +209,9 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public String dataLoadError() {
+        if (view == View.AUDIT) {
+            return audit.error();
+        }
         refresh();
         return pending != null ? null : error != null ? error : rows().isEmpty() ? "No semantic definitions or experts." : null;
     }
@@ -347,6 +361,12 @@ class SemanticTab extends AbstractTableTab {
 
     private void view(View selected) {
         view = selected;
+        if (view == View.AUDIT) {
+            sample = null;
+            filterInput = null;
+            audit.ensureLoaded();
+            return;
+        }
         filter = "";
         focus = Focus.LIST;
         tableState.setOffset(0);
@@ -364,10 +384,14 @@ class SemanticTab extends AbstractTableTab {
     }
 
     boolean isInputActive() {
-        return filterInput != null || sample != null || focus == Focus.PLAYGROUND;
+        return view == View.AUDIT ? audit.inputActive() : filterInput != null || sample != null || focus == Focus.PLAYGROUND;
     }
 
     void handlePaste(String text) {
+        if (view == View.AUDIT) {
+            audit.paste(text);
+            return;
+        }
         if (sample != null) {
             sample.handlePaste(text);
         } else if (focus == Focus.PLAYGROUND && playground != null) {
@@ -384,6 +408,13 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public boolean handleKeyEvent(KeyEvent key) {
+        if (view == View.AUDIT) {
+            if (!audit.inputActive() && key.isChar('v')) {
+                view(View.DEFINITIONS);
+                return true;
+            }
+            return audit.key(key);
+        }
         refresh();
         if (sample != null) {
             sample.handleKeyEvent(key);
@@ -501,6 +532,9 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public boolean handleEscape() {
+        if (view == View.AUDIT) {
+            return audit.escape();
+        }
         if (focus == Focus.PLAYGROUND) {
             focus = Focus.LIST;
             return true;
@@ -531,6 +565,10 @@ class SemanticTab extends AbstractTableTab {
     }
 
     private void navigate(int delta) {
+        if (view == View.AUDIT) {
+            audit.navigate(delta);
+            return;
+        }
         if (sample != null) {
             sample.handleKeyEvent(KeyEvent.ofKey(delta < 0 ? KeyCode.UP : KeyCode.DOWN));
         } else if (focus == Focus.PLAYGROUND && playground != null) {
@@ -557,6 +595,9 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public boolean handleMouseEvent(MouseEvent event, Rect area) {
+        if (view == View.AUDIT) {
+            return false;
+        }
         if (sample != null) {
             sample.handleMouseEvent(event);
             return true;
@@ -619,6 +660,10 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public void render(Frame frame, Rect area) {
+        if (view == View.AUDIT) {
+            audit.render(frame, area);
+            return;
+        }
         if (ctx.findSelectedIntegration() == null && data != null && Objects.equals(selectionId, ctx.selectedPid)) {
             // Keep the draft visible while this application's connection is lost.
             renderContent(frame, area, null);
@@ -820,6 +865,9 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public boolean setFilter(String value) {
+        if (view == View.AUDIT) {
+            return audit.setFilter(value);
+        }
         filter = value == null ? "" : value.strip();
         restoreSelection();
         relationships.reset();
@@ -828,6 +876,10 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public void renderFooter(List<Span> spans) {
+        if (view == View.AUDIT) {
+            audit.footer(spans);
+            return;
+        }
         if (sample != null) {
             sample.renderFooter(spans);
         } else if (focus == Focus.PLAYGROUND && playground != null) {
@@ -866,11 +918,14 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public Boolean isDetailFocused() {
-        return focus == Focus.DETAIL;
+        return view == View.AUDIT ? audit.detailFocused() : focus == Focus.DETAIL;
     }
 
     @Override
     public SelectionContext getSelectionContext() {
+        if (view == View.AUDIT) {
+            return audit.selectionContext();
+        }
         List<JsonObject> visible = focus == Focus.USES ? uses() : rows();
         List<String> names
                 = visible.stream().map(row -> text(row, view == View.EXPERTS && focus != Focus.USES ? "reference" : "name"))
@@ -881,6 +936,9 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public JsonObject getTableDataAsJson() {
+        if (view == View.AUDIT) {
+            return audit.snapshot();
+        }
         refresh();
         if (data == null) {
             return null;
@@ -906,6 +964,13 @@ class SemanticTab extends AbstractTableTab {
 
     @Override
     public boolean setInputValue(String field, String value) {
+        if ("audit.view".equals(field)) {
+            view(View.AUDIT);
+            return true;
+        }
+        if (view == View.AUDIT) {
+            return audit.setInput(field, value);
+        }
         refresh();
         if (sample != null) {
             return sample.setInputValue(field, value);
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolDefinitions.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolDefinitions.java
index 2ef2437d4c96..91f3443db27c 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolDefinitions.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolDefinitions.java
@@ -394,12 +394,28 @@ final class TuiToolDefinitions {
                         "tab", propDef("string",
                                 "Tab name to filter (e.g. 'Classpath'). If omitted, uses the active tab.")),
                 List.of("filter"))));
+        tools.add(toToolDef(toolDef(
+                "tui_get_audit",
+                "Read retained semantic audit records and backend health without changing the TUI. "
+                                 + "Use eventId alone for a record and its evidence; otherwise pass filters and a returned cursor.",
+                Map.of("category", propDef("string", "evaluation, decision or request"),
+                        "action", propDef("string", "Explicit route action"),
+                        "expert", propDef("string", "Expert bean name"),
+                        "routeId", propDef("string", "Route ID"),
+                        "namespace", propDef("string", "Application namespace"),
+                        "correlationId", propDef("string", "Application correlation ID"),
+                        "since", propDef("string", "Inclusive ISO-8601 timestamp"),
+                        "cursor", propDef("string", "nextCursor from the same query"),
+                        "limit", propDef("integer", "Page size, 1 to 200; default 50"),
+                        "eventId", propDef("string", "Event and linked evidence")),
+                List.of())));
         tools.add(toToolDef(toolDef(
                 "tui_set_input",
                 "Edit visible fields without submitting. SQL Query: sql. HTTP: path, body, method, content-type, accept. "
                                  + "Spans/Classpath: filter. Semantic Experts: input, inputMode (text/json), "
                                  + "parameter.<name> (scalars as text, maps/lists as JSON). Open Semantic sample: "
                                  + "sample (exchange JSON), sample.body (text), sample.headers/sample.variables (JSON objects). "
+                                 + "Semantic Audit: audit.view, audit.filter, audit.page (latest/older), audit.eventId. "
                                  + "Read drafts/results with tui_get_table; send Ctrl+r explicitly to evaluate Semantic input.",
                 Map.of("field", propDef("string",
                         "Field name (see supported fields above)"),
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolGroups.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolGroups.java
index 8233a4f74c8a..137edb8fffb7 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolGroups.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolGroups.java
@@ -80,12 +80,15 @@ final class TuiToolGroups {
         return switch (group) {
             case SQL -> List.of(SQL_TOOL, UPDATE_ROW_TOOL);
             case HTTP -> List.of(HTTP_ENDPOINTS_TOOL, HTTP_REQUEST_TOOL);
+            case SEMANTIC -> List.of("tui_get_audit");
             default -> List.of();
         };
     }
 
     static String guidance(ToolGroup group, AppFeatures f) {
         return switch (group) {
+            case SEMANTIC ->
+                "Semantic: tui_get_audit reads retained evaluations, route decisions and linked evidence without replay.";
             case SQL -> "SQL: " + ToolGroups.describeSql(f)
                         + ". Table names come from the SQL trace (tui_get_table tab 'SQL Trace'); don't guess a schema.";
             case TRACING -> {
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolRegistry.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolRegistry.java
index 4fe764360ee7..153c02fd6f18 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolRegistry.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/java/org/apache/camel/dsl/jbang/core/commands/tui/TuiToolRegistry.java
@@ -17,6 +17,8 @@
 package org.apache.camel.dsl.jbang.core.commands.tui;
 
 import java.nio.file.Path;
+import java.time.Instant;
+import java.time.format.DateTimeParseException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -231,17 +233,17 @@ class TuiToolRegistry {
 
     /** The TUI's own read-only tools; the shared tools add those flagged read-only in the registry. */
     private static final Set<String> READ_ONLY_TUI_TOOLS = Set.of(
-            "tui_get_ai_log", "tui_get_diagram", "tui_get_events", "tui_get_history", "tui_get_mcp_log",
+            "tui_get_audit", "tui_get_ai_log", "tui_get_diagram", "tui_get_events", "tui_get_history", "tui_get_mcp_log",
             "tui_get_ollama", "tui_get_options", "tui_get_processor_detail", "tui_get_readme", "tui_get_screen",
             "tui_get_spans", "tui_http_endpoints",
             "tui_get_state", "tui_get_status", "tui_get_table", "tui_get_themes", "tui_get_topology",
             "tui_list_examples", "tui_locate", "tui_wait_for_idle");
 
     /**
-     * Tools that only return information and never change the TUI, the integration or its data. The ACP permission
-     * handler approves calls to these without asking; anything else, including camel_control, tui_send_message and
-     * tui_execute_sql, is put in front of the user. camel_eval_expression is read-only because it evaluates an
-     * expression against a scratch exchange and sends nothing through a route.
+     * Tools that inspect information without executing application actions, editing data or changing the visible view.
+     * The ACP permission handler approves calls to these without asking; anything else, including camel_control,
+     * tui_send_message and tui_execute_sql, is put in front of the user. camel_eval_expression is read-only because it
+     * evaluates an expression against a scratch exchange and sends nothing through a route.
      */
     static final Set<String> READ_ONLY_TOOLS = Stream.concat(
             READ_ONLY_TUI_TOOLS.stream(),
@@ -261,6 +263,11 @@ class TuiToolRegistry {
         return tools;
     }
 
+    List<ToolDef> getAvailableToolDefinitions(Collection<String> selected) {
+        return getToolDefinitions().stream()
+                .filter(tool -> !"tui_get_audit".equals(tool.name()) || selected.contains(tool.name())).toList();
+    }
+
     /**
      * Returns only the {@link #CORE_TOOLS} definitions, in registry order.
      */
@@ -301,6 +308,7 @@ class TuiToolRegistry {
             case "tui_draw" -> callDraw(args);
             case "tui_draw_clear" -> callDrawClear();
             case "tui_get_table" -> callGetTable(args);
+            case "tui_get_audit" -> callGetAudit(args);
             case "tui_action" -> callAction(args);
             case "tui_get_themes" -> callGetThemes();
             case "tui_set_theme" -> callSetTheme(args);
@@ -992,6 +1000,43 @@ class TuiToolRegistry {
         return Jsoner.serialize(result);
     }
 
+    private String callGetAudit(Map<String, Object> args) {
+        Set<String> filters = Set.of("category", "action", "expert", "routeId", "namespace", "correlationId", "since");
+        JsonObject request = new JsonObject();
+        request.put("action", "semantic-audit");
+        try {
+            for (var entry : args.entrySet()) {
+                String key = entry.getKey();
+                if ("limit".equals(key)) {
+                    int limit = Integer.parseInt(String.valueOf(entry.getValue()));
+                    if (limit < 1 || limit > 200) {
+                        throw new IllegalArgumentException();
+                    }
+                    request.put(key, limit);
+                } else {
+                    if ((!filters.contains(key) && !Set.of("eventId", "cursor").contains(key))
+                            || !(entry.getValue() instanceof String value) || value.isBlank()
+                            || value.length() > ("cursor".equals(key) ? 512 : 256)) {
+                        throw new IllegalArgumentException();
+                    }
+                    if ("since".equals(key)) {
+                        Instant.parse(value);
+                    }
+                    request.put("action".equals(key) ? "auditAction" : key, value);
+                }
+            }
+            if (args.containsKey("eventId") && args.size() > 1) {
+                throw new IllegalArgumentException();
+            }
+            JsonObject response = facade.queryAudit(request);
+            return response == null
+                    ? "Error: select a connected integration with semantic audit support"
+                    : Jsoner.serialize(response);
+        } catch (IllegalArgumentException | DateTimeParseException invalid) {
+            return "Error: invalid audit query; use filters and cursor/limit, or eventId alone";
+        }
+    }
+
     private String callGetTable(Map<String, Object> args) {
         String tab = args.get("tab") instanceof String s ? s : null;
         JsonObject data = facade.getTableData(tab);
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/resources/tui/help/semantic.md b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/resources/tui/help/semantic.md
index e715c9f87791..b950b7140b85 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/resources/tui/help/semantic.md
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/main/resources/tui/help/semantic.md
@@ -16,7 +16,7 @@ The linked-definition highlight follows a matching operation, or clears when no
 
 ## Keys
 
-- `v` — cycle Definitions, Experts and Relationships
+- `v` — cycle Definitions, Experts, Relationships and Audit
 - `Tab` — focus the next pane
 - `Up/Down`, `PgUp/PgDn` — navigate the focused pane
 - `Home/End` — first/last declaration
@@ -92,3 +92,31 @@ with `input`, `inputMode` (`text`/`json`), or `parameter.<name>` in Experts. Map
 use JSON and populate the normal controls. For an open sample popup, use `sample` (exchange
 JSON), `sample.body` (text), or `sample.headers` / `sample.variables` (JSON objects).
 Reading or editing never runs the expert; Ctrl+r explicitly evaluates the draft.
+
+
+## Audit history
+
+Choose **Audit** with `v` to browse retained evaluation evidence and explicit route
+decisions. Capture runs in the application while the TUI is disconnected. Audit settings
+come from the semantic DSL; expert overrides take precedence over the master default.
+Auditing and OpenTelemetry are independent.
+
+- `/` edits exact `field=value` filters, separated by spaces. Available fields are
+  `category`, `action`, `expert`, `routeId`, `namespace`, `correlationId` and `since`.
+  Example: `expert=security since=2026-10-09T12:00:00Z`.
+- Up/Down select a record. `Tab` or Enter focuses the inspector; arrows scroll its details.
+- `n` loads older records; `g` returns to the latest page; `r` refreshes the current page.
+- Esc leaves details or clears the current filter.
+
+Wide terminals show timestamp, action, category, operation, target, namespace, reason and
+correlation columns. Smaller terminals move fields into the inspector. A route action is
+only present for an explicit decision. Linked evaluations retain their captured result
+meaning; missing/evicted evidence is shown as unavailable. Backend status shows the master
+and expert settings, reader, evictions, drops, errors and whether a Camel OpenTelemetry
+tracer is active. This does not assert that an external collector received a trace.
+
+The MCP tool **`tui_get_audit`** reads history without moving the screen or changing its filters or selection.
+Pass `eventId` alone to inspect a record and its evidence. For pages, pass `category`, `action`, `expert`,
+`routeId`, `namespace`, `correlationId`, `since`, `limit` and a returned `cursor` as needed.
+`tui_get_table` reads the visible Audit screen; `tui_set_input` changes it explicitly.
+Audit refreshes are coalesced while a query is pending; changed filters use the latest submitted value.
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelPromptBudgetTest.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelPromptBudgetTest.java
index 7bd7969a8983..035c9744b4a4 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelPromptBudgetTest.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelPromptBudgetTest.java
@@ -17,12 +17,14 @@
 package org.apache.camel.dsl.jbang.core.commands.tui;
 
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 import org.apache.camel.dsl.jbang.core.commands.LlmClient;
+import org.apache.camel.dsl.jbang.core.commands.ai.AppFeatures;
 import org.apache.camel.util.json.JsonObject;
 import org.junit.jupiter.api.Test;
 
@@ -164,6 +166,20 @@ class AiPanelPromptBudgetTest {
                 "full prefix grew to ~" + full.totalTokens() + " tokens, budget " + FULL_BUDGET_TOKENS + ": " + full);
     }
 
+    @Test
+    void semanticHistoryHasABoundedAdditionalPromptCost() {
+        for (String mode : List.of(AiPanel.TOOL_MODE_CORE, AiPanel.TOOL_MODE_FULL)) {
+            AiPanelToolGroupsTest.FakeApp app = new AiPanelToolGroupsTest.FakeApp();
+            app.features = AiPanelToolGroupsTest.EVERYTHING.merge(AppFeatures.fromStatus(
+                    new JsonObject(Map.of("devConsoles", List.of("semantic-audit")))));
+            AiPanel panel = AiPanelToolGroupsTest.panel(mode, app);
+            panel.refreshToolGroupsForTesting();
+            Prefix prefix = measure(mode + "+semantic", panel);
+            System.out.println("AI panel semantic prefix: " + prefix);
+            assertTrue(prefix.totalTokens() <= (AiPanel.TOOL_MODE_CORE.equals(mode) ? 6100 : 11000));
+        }
+    }
+
     @Test
     void systemPromptStaysShortAndFreeOfTheToolList() {
         AiPanel panel = new AiPanel();
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelTest.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelTest.java
index 13de5029cab0..e4b70a3d481a 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelTest.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelTest.java
@@ -1411,8 +1411,9 @@ class AiPanelTest {
         RecordingLlmClient client = new RecordingLlmClient("ok");
         panel.setClientForTesting(client);
 
-        // auto mode: a hosted provider gets every tool
-        assertEquals(new TuiToolRegistry(null).getToolDefinitions().size(), panel.toolDefinitionsForTesting().size());
+        // auto mode: a hosted provider gets all tools available for the selected integration
+        assertEquals(new TuiToolRegistry(null).getAvailableToolDefinitions(List.of()).size(),
+                panel.toolDefinitionsForTesting().size());
         assertTrue(panel.systemPromptForTesting().contains("tui_draw_shape"));
 
         // auto mode: a local provider only gets the core set, and the prompt no longer suggests drawing tools
@@ -1434,7 +1435,8 @@ class AiPanelTest {
         panel.setClientForTesting(client);
 
         panel.setToolModeForTesting("full");
-        assertEquals(new TuiToolRegistry(null).getToolDefinitions().size(), panel.toolDefinitionsForTesting().size());
+        assertEquals(new TuiToolRegistry(null).getAvailableToolDefinitions(List.of()).size(),
+                panel.toolDefinitionsForTesting().size());
 
         panel.setToolModeForTesting("core");
         client.withApiType(LlmClient.ApiType.openai);
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelToolGroupsTest.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelToolGroupsTest.java
index d71d35624f72..190a8af1de39 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelToolGroupsTest.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/AiPanelToolGroupsTest.java
@@ -23,6 +23,7 @@ import org.apache.camel.dsl.jbang.core.commands.LlmClient;
 import org.apache.camel.dsl.jbang.core.commands.ai.AppFeatures;
 import org.apache.camel.dsl.jbang.core.commands.ai.HttpEndpoints;
 import org.apache.camel.dsl.jbang.core.commands.ai.ToolGroup;
+import org.apache.camel.util.json.JsonObject;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -86,6 +87,25 @@ class AiPanelToolGroupsTest {
         return panel.toolDefinitionsForTesting().stream().map(LlmClient.ToolDef::name).toList();
     }
 
+    @Test
+    void semanticAuditLoadsOnlyForAnIntegrationWithHistoryInBothModes() {
+        AppFeatures semantic = AppFeatures.fromStatus(new JsonObject(
+                Map.of("devConsoles", List.of("semantic-audit"))));
+        assertTrue(semantic.semanticAudit());
+        for (String mode : List.of(AiPanel.TOOL_MODE_CORE, AiPanel.TOOL_MODE_FULL)) {
+            FakeApp app = new FakeApp();
+            app.features = AppFeatures.none();
+            AiPanel panel = panel(mode, app);
+            panel.refreshToolGroupsForTesting();
+            assertFalse(panel.toolDefinitionsForTesting().stream().anyMatch(t -> t.name().equals("tui_get_audit")));
+            app.features = semantic;
+            app.reloads++;
+            panel.refreshToolGroupsForTesting();
+            assertTrue(panel.toolDefinitionsForTesting().stream().anyMatch(t -> t.name().equals("tui_get_audit")));
+            assertTrue(panel.toolGroupsForTesting().groups().contains(ToolGroup.SEMANTIC));
+        }
+    }
+
     @Test
     void theSqlGroupAddsTheSqlTools() {
         AiPanel panel = panel(AiPanel.TOOL_MODE_CORE, new FakeApp());
@@ -191,7 +211,7 @@ class AiPanelToolGroupsTest {
         String before = panel.systemPromptForTesting();
         panel.refreshToolGroupsForTesting();
 
-        assertEquals(0, app.reads, "the full set does not need the status");
+        assertEquals(1, app.reads, "full mode also discovers integration-specific audit tools");
         assertEquals(before, panel.systemPromptForTesting());
         assertFalse(panel.systemPromptForTesting().contains("The selected integration"));
         assertEquals(toolNames(plain), toolNames(panel));
diff --git a/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticTabTest.java b/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticTabTest.java
index 0618123ac32b..ccdc8d3933ed 100644
--- a/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticTabTest.java
+++ b/dsl/camel-jbang/camel-jbang-plugin-tui/src/test/java/org/apache/camel/dsl/jbang/core/commands/tui/SemanticTabTest.java
@@ -41,6 +41,7 @@ import org.junit.jupiter.api.Test;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.awaitility.Awaitility.await;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 class SemanticTabTest {
@@ -58,6 +59,136 @@ class SemanticTabTest {
                  "state":"${header.text}","resultType":"boolean","parameters":{}}]}
             """;
 
+    @Test
+    void auditMcpQueriesWithoutChangingTheVisibleView() throws Exception {
+        try (var runtime = new Runtime()) {
+            var tab = loaded(runtime);
+            var bridge = mock(McpFacade.MonitorBridge.class);
+            when(bridge.activeTab()).thenReturn(tab);
+            var registry = mock(TabRegistry.class);
+            when(registry.moreTabs()).thenReturn(List.of());
+            var facade = new McpFacade(
+                    runtime, new AtomicReference<>(List.of()), null, null, null, null, null,
+                    null, null, null, registry, null, bridge);
+            var tools = new TuiToolRegistry(facade);
+            JsonObject before = tab.getTableDataAsJson();
+            JsonObject history = (JsonObject) Jsoner.deserialize(tools.execute("tui_get_audit", new JsonObject()));
+            assertThat(SemanticTab.objects(history, "records")).hasSize(2);
+            tools.execute("tui_get_audit", new JsonObject(Map.of("expert", "security", "action", "block", "limit", 1)));
+            assertThat(runtime.requests).anySatisfy(request -> assertThat(request)
+                    .containsEntry("auditAction", "block").containsEntry("expert", "security").containsEntry("limit", 1));
+            JsonObject details = (JsonObject) Jsoner.deserialize(tools.execute("tui_get_audit",
+                    new JsonObject(Map.of("eventId", "evaluation-1"))));
+            assertThat(details.getJsonObject("record")).containsEntry("category", "evaluation");
+            assertThat(tab.getTableDataAsJson()).isEqualTo(before);
+            verifyNoInteractions(bridge);
+            assertThat(runtime.requests).noneSatisfy(r -> assertThat(r).containsEntry("action", "semantic-evaluate"));
+            int requests = runtime.requests.size();
+            assertThat(tools.execute("tui_get_audit", new JsonObject(Map.of("body", "secret")))).startsWith("Error:");
+            assertThat(tools.execute("tui_get_audit", new JsonObject(Map.of("eventId", "x", "limit", 1)))).startsWith("Error:");
+            assertThat(tools.execute("tui_get_audit", new JsonObject(Map.of("limit", 0)))).startsWith("Error:");
+            assertThat(runtime.requests).hasSize(requests);
+            tab.setInputValue("audit.view", "");
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            String rendered = TuiTestHelper.renderToString(tab, 180, 45);
+            assertThat(rendered).contains("TIMESTAMP", "REASON CODE", "tools/call", "support-request", "Master: true");
+            assertThat(TuiTestHelper.renderToString(tab, 80, 24)).contains("CATEGORY", "EXPERT");
+        }
+    }
+
+    @Test
+    void auditFilterDiscardsPendingDetailsWhenTheNewPageIsEmpty() throws Exception {
+        try (var runtime = new Runtime()) {
+            var tab = loaded(runtime);
+            tab.setInputValue("audit.view", "");
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            runtime.detailsRelease = new CountDownLatch(1);
+            runtime.detailsEntered = new CountDownLatch(1);
+            tab.setInputValue("audit.eventId", "evaluation-1");
+            assertThat(runtime.detailsEntered.await(5, TimeUnit.SECONDS)).isTrue();
+            tab.setInputValue("audit.filter", "expert=absent");
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            assertThat(tab.getTableDataAsJson().getInteger("totalRows")).isZero();
+            runtime.detailsRelease.countDown();
+            await().atMost(5, TimeUnit.SECONDS).until(() -> runtime.detailsFinished);
+            assertThat(tab.getTableDataAsJson()).containsEntry("selectedRecord", null).containsEntry("selectedEventId", null);
+        }
+    }
+
+    @Test
+    void auditRefreshPreservesSelectionByIdentityAndOldDetailsCannotReplaceNewSelection() throws Exception {
+        try (var runtime = new Runtime()) {
+            var tab = loaded(runtime);
+            tab.setInputValue("audit.view", "");
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            tab.navigateDown();
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            assertThat(tab.getTableDataAsJson()).containsEntry("selectedEventId", "evaluation-1");
+            tab.handleKeyEvent(KeyEvent.ofChar('r'));
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            assertThat(tab.getTableDataAsJson()).containsEntry("selectedEventId", "evaluation-1");
+            tab.setInputValue("audit.eventId", "decision-2");
+            tab.setInputValue("audit.eventId", "evaluation-1");
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            assertThat(tab.getTableDataAsJson().getJsonObject("selectedRecord")).containsEntry("eventId", "evaluation-1");
+        }
+    }
+
+    @Test
+    void auditCoalescesRefreshesAndAppliesTheLatestFilterAfterAPendingQuery() throws Exception {
+        try (var runtime = new Runtime()) {
+            var tab = loaded(runtime);
+            tab.setInputValue("audit.view", "");
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            long before = auditQueries(runtime);
+            runtime.pageEntered = new CountDownLatch(1);
+            runtime.pageRelease = new CountDownLatch(1);
+            tab.handleKeyEvent(KeyEvent.ofChar('r'));
+            assertThat(runtime.pageEntered.await(5, TimeUnit.SECONDS)).isTrue();
+            for (int i = 0; i < 20; i++) {
+                tab.handleKeyEvent(KeyEvent.ofChar('r'));
+                tab.handleKeyEvent(KeyEvent.ofChar('g'));
+            }
+            tab.setInputValue("audit.filter", "expert=security");
+            tab.setInputValue("audit.filter", "expert=absent");
+            assertThat(tab.setInputValue("audit.page", "older")).isFalse();
+            assertThat(auditQueries(runtime)).isEqualTo(before + 1);
+            runtime.pageRelease.countDown();
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            assertThat(auditQueries(runtime)).isEqualTo(before + 2);
+            assertThat(tab.getTableDataAsJson().getInteger("totalRows")).isZero();
+            assertThat(runtime.requests).noneSatisfy(r -> assertThat(r).containsEntry("expert", "security"));
+        }
+    }
+
+    @Test
+    void auditRefreshKeepsTheCurrentPageAndGoReturnsToLatest() throws Exception {
+        try (var runtime = new Runtime()) {
+            runtime.pagedAudit = true;
+            var tab = loaded(runtime);
+            tab.setInputValue("audit.view", "");
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            tab.handleKeyEvent(KeyEvent.ofChar('n'));
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            tab.handleKeyEvent(KeyEvent.ofChar('r'));
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            var queries = runtime.requests.stream().filter(r -> "semantic-audit".equals(r.getString("action"))
+                    && !r.containsKey("eventId")).toList();
+            assertThat(queries).hasSize(3);
+            assertThat(queries.get(1)).containsEntry("cursor", "older");
+            assertThat(queries.get(2)).containsEntry("cursor", "older");
+            tab.handleKeyEvent(KeyEvent.ofChar('g'));
+            await().atMost(5, TimeUnit.SECONDS).until(() -> !tab.ensureDataLoaded());
+            assertThat(runtime.requests.stream().filter(r -> "semantic-audit".equals(r.getString("action"))
+                    && !r.containsKey("eventId")).toList().get(3)).doesNotContainKey("cursor");
+        }
+    }
+
+    private static long auditQueries(Runtime runtime) {
+        return runtime.requests.stream().filter(r -> "semantic-audit".equals(r.getString("action"))
+                && !r.containsKey("eventId")).count();
+    }
+
     @Test
     void mcpCanReadAndEditTheVisibleDraftWithoutInvokingAnExpert() throws Exception {
         try (var runtime = new Runtime()) {
@@ -167,7 +298,7 @@ class SemanticTabTest {
             assertThat(definitions).doesNotContain("Evaluate sample", "Item type", "Integer: false");
             assertThat(definitions).contains("DEFINITION", "EXPERT", "OPERATION", "RESULT", "STATE", "screenPrompt", "${body}");
             assertThat(tab.subViewBar().views()).extracting(SubViewBar.View::label).containsExactly("Definitions", "Experts",
-                    "Relationships");
+                    "Relationships", "Audit");
             tab.handleKeyEvent(KeyEvent.ofKey(KeyCode.ENTER));
             String experts = TuiTestHelper.renderToString(tab, 120, 30);
             assertThat(experts).contains("EXPERT", "1 operation", "Expert contract", "Default:",
@@ -874,6 +1005,12 @@ class SemanticTabTest {
         final List<JsonObject> requests = new CopyOnWriteArrayList<>();
         volatile CountDownLatch release;
         volatile boolean firstFinished;
+        volatile CountDownLatch pageEntered;
+        volatile CountDownLatch pageRelease;
+        volatile boolean pagedAudit;
+        volatile CountDownLatch detailsRelease;
+        volatile CountDownLatch detailsEntered;
+        volatile boolean detailsFinished;
         volatile RuntimeException failure;
         volatile String overview = OVERVIEW;
         volatile String answer = "{\"status\":\"success\",\"value\":true,\"elapsedMillis\":4}";
@@ -894,6 +1031,51 @@ class SemanticTabTest {
                     }
                     firstFinished = true;
                 }
+                if ("semantic-audit".equals(request.getString("action"))) {
+                    JsonObject evaluation = new JsonObject(
+                            Map.of("eventId", "evaluation-1", "category", "evaluation", "expert", "security",
+                                    "operation", "injection", "status", "success", "timestamp", "2026-10-09T14:20:29.411Z",
+                                    "reasonCode", "evaluation_completed", "result", new JsonObject(Map.of("value", true))));
+                    evaluation.put("provider", "test");
+                    evaluation.put("model", "detector-v2");
+                    evaluation.put("revision", "abc123");
+                    JsonObject decision = new JsonObject(
+                            Map.of("eventId", "decision-2", "category", "decision", "action", "block",
+                                    "operation", "tools/call", "target", "support-request", "reasonCode", "prompt_injection",
+                                    "timestamp", "2026-10-09T14:20:29.418Z", "evidence", List.of("evaluation-1")));
+                    JsonObject status = new JsonObject(
+                            Map.of("enabled", true, "experts", new JsonObject(Map.of("security", true)),
+                                    "reader", "memory", "dropped", 0, "sinkErrors", new JsonObject(), "openTelemetry",
+                                    "inactive"));
+                    if (request.getString("eventId") != null) {
+                        if (detailsRelease != null) {
+                            detailsEntered.countDown();
+                            if (!detailsRelease.await(5, TimeUnit.SECONDS)) {
+                                throw new IllegalStateException("details were not released");
+                            }
+                            detailsFinished = true;
+                        }
+                        return new JsonObject(
+                                Map.of("record", "evaluation-1".equals(request.getString("eventId")) ? evaluation : decision,
+                                        "evidence",
+                                        "evaluation-1".equals(request.getString("eventId")) ? List.of() : List.of(evaluation),
+                                        "audit", status));
+                    }
+                    if (pageRelease != null) {
+                        pageEntered.countDown();
+                        if (!pageRelease.await(5, TimeUnit.SECONDS)) {
+                            throw new IllegalStateException("page was not released");
+                        }
+                    }
+                    var page = new JsonObject(
+                            Map.of("records",
+                                    "absent".equals(request.getString("expert")) ? List.of() : List.of(decision, evaluation),
+                                    "audit", status, "evicted", 0, "cursorExpired", false));
+                    if (pagedAudit && !request.containsKey("cursor")) {
+                        page.put("nextCursor", "older");
+                    }
+                    return page;
+                }
                 if ("semantic-evaluate".equals(request.getString("action"))) {
                     if (failure != null) {
                         throw failure;
@@ -910,6 +1092,12 @@ class SemanticTabTest {
 
         @Override
         public void close() {
+            if (pageRelease != null) {
+                pageRelease.countDown();
+            }
+            if (detailsRelease != null) {
+                detailsRelease.countDown();
+            }
             if (release != null) {
                 release.countDown();
             }
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-validator/src/test/java/org/apache/camel/dsl/yaml/validator/SemanticSchemaTest.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-validator/src/test/java/org/apache/camel/dsl/yaml/validator/SemanticSchemaTest.java
index bed6c0469899..d189f7313a3c 100644
--- a/dsl/camel-yaml-dsl/camel-yaml-dsl-validator/src/test/java/org/apache/camel/dsl/yaml/validator/SemanticSchemaTest.java
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-validator/src/test/java/org/apache/camel/dsl/yaml/validator/SemanticSchemaTest.java
@@ -97,6 +97,11 @@ class SemanticSchemaTest {
     void semanticRequiresExactlyOneDeclarationBlock(boolean canonical) throws Exception {
         var validator = new YamlValidator(canonical);
         assertThat(validator.validate("- semantic: {expert: content}")).isNotEmpty();
+        assertThat(validator.validate("- semantic: {}")).isNotEmpty();
+        assertThat(validator.validate("- semantic: {audit: {enabled: true}}")).isEmpty();
+        assertThat(validator.validate("- semantic: {audit: {enabled: true}, evaluation: {q: {operation: detect}}}"))
+                .isEmpty();
+        assertThat(validator.validate("- semantic: {audit: {unknown: true}}")).isNotEmpty();
         assertThat(validator.validate("- semantic: {question: {}}")).isNotEmpty();
         assertThat(validator.validate("- semantic: {question: {}, evaluation: {}}")).isNotEmpty();
         assertThat(validator.validate("- semantic: {evaluation: {q: {operation: detect, uncertaintyPolicy: expert-policy}}}"))
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-canonical.json b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-canonical.json
index 677d10d97025..8a0cfe6ff2e1 100644
--- a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-canonical.json
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-canonical.json
@@ -13586,6 +13586,108 @@
         }
       },
       "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer" : {
+        "type" : "object",
+        "anyOf" : [ {
+          "oneOf" : [ {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$EvaluationDeclarationSchema"
+          }, {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditDeclarationSchema"
+          }, {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditedEvaluationDeclarationSchema"
+          } ]
+        } ]
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditDeclarationSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "audit" : {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditSchema"
+          },
+          "expert" : {
+            "type" : "string"
+          },
+          "state" : {
+            "type" : "string"
+          }
+        },
+        "required" : [ "audit" ]
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditExpertSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "enabled" : {
+            "type" : "boolean"
+          }
+        },
+        "required" : [ "enabled" ]
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "capacity" : {
+            "type" : "integer"
+          },
+          "enabled" : {
+            "type" : "boolean"
+          },
+          "experts" : {
+            "type" : "object",
+            "additionalProperties" : {
+              "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditExpertSchema"
+            }
+          },
+          "queueCapacity" : {
+            "type" : "integer"
+          },
+          "reader" : {
+            "type" : "string"
+          },
+          "sinks" : {
+            "type" : "array",
+            "items" : {
+              "type" : "string"
+            }
+          }
+        }
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditedEvaluationDeclarationSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "audit" : {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditSchema"
+          },
+          "evaluation" : {
+            "type" : "object",
+            "additionalProperties" : {
+              "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$EvaluationSchema"
+            }
+          },
+          "expert" : {
+            "type" : "string"
+          },
+          "state" : {
+            "type" : "string"
+          }
+        },
+        "required" : [ "audit", "evaluation" ]
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$DeclarationSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "expert" : {
+            "type" : "string"
+          },
+          "state" : {
+            "type" : "string"
+          }
+        }
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$EvaluationDeclarationSchema" : {
         "type" : "object",
         "additionalProperties" : false,
         "properties" : {
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-model.json b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-model.json
index ede879de9011..7472732229c7 100644
--- a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-model.json
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-model.json
@@ -20536,6 +20536,96 @@
     },
     "semantic" : {
       "isListItem" : true,
+      "children" : [ {
+        "name" : "evaluation",
+        "type" : "map",
+        "ref" : "semanticDefinitionDeserializer$EvaluationSchema",
+        "required" : true
+      }, {
+        "name" : "expert",
+        "type" : "string"
+      }, {
+        "name" : "state",
+        "type" : "string"
+      }, {
+        "name" : "audit",
+        "type" : "object",
+        "ref" : "semanticDefinitionDeserializer$AuditSchema",
+        "required" : true
+      } ]
+    },
+    "semanticDefinitionDeserializer$AuditDeclarationSchema" : {
+      "children" : [ {
+        "name" : "audit",
+        "type" : "object",
+        "ref" : "semanticDefinitionDeserializer$AuditSchema",
+        "required" : true
+      }, {
+        "name" : "expert",
+        "type" : "string"
+      }, {
+        "name" : "state",
+        "type" : "string"
+      } ]
+    },
+    "semanticDefinitionDeserializer$AuditExpertSchema" : {
+      "children" : [ {
+        "name" : "enabled",
+        "type" : "boolean",
+        "required" : true
+      } ]
+    },
+    "semanticDefinitionDeserializer$AuditSchema" : {
+      "children" : [ {
+        "name" : "capacity",
+        "type" : "integer"
+      }, {
+        "name" : "enabled",
+        "type" : "boolean"
+      }, {
+        "name" : "experts",
+        "type" : "map",
+        "ref" : "semanticDefinitionDeserializer$AuditExpertSchema"
+      }, {
+        "name" : "queueCapacity",
+        "type" : "integer"
+      }, {
+        "name" : "reader",
+        "type" : "string"
+      }, {
+        "name" : "sinks",
+        "type" : "array"
+      } ]
+    },
+    "semanticDefinitionDeserializer$AuditedEvaluationDeclarationSchema" : {
+      "children" : [ {
+        "name" : "audit",
+        "type" : "object",
+        "ref" : "semanticDefinitionDeserializer$AuditSchema",
+        "required" : true
+      }, {
+        "name" : "evaluation",
+        "type" : "map",
+        "ref" : "semanticDefinitionDeserializer$EvaluationSchema",
+        "required" : true
+      }, {
+        "name" : "expert",
+        "type" : "string"
+      }, {
+        "name" : "state",
+        "type" : "string"
+      } ]
+    },
+    "semanticDefinitionDeserializer$DeclarationSchema" : {
+      "children" : [ {
+        "name" : "expert",
+        "type" : "string"
+      }, {
+        "name" : "state",
+        "type" : "string"
+      } ]
+    },
+    "semanticDefinitionDeserializer$EvaluationDeclarationSchema" : {
       "children" : [ {
         "name" : "evaluation",
         "type" : "map",
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl.json b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl.json
index bddc9561c35f..2314c56c162b 100644
--- a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl.json
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl.json
@@ -16486,6 +16486,108 @@
         }
       },
       "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer" : {
+        "type" : "object",
+        "anyOf" : [ {
+          "oneOf" : [ {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$EvaluationDeclarationSchema"
+          }, {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditDeclarationSchema"
+          }, {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditedEvaluationDeclarationSchema"
+          } ]
+        } ]
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditDeclarationSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "audit" : {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditSchema"
+          },
+          "expert" : {
+            "type" : "string"
+          },
+          "state" : {
+            "type" : "string"
+          }
+        },
+        "required" : [ "audit" ]
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditExpertSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "enabled" : {
+            "type" : "boolean"
+          }
+        },
+        "required" : [ "enabled" ]
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "capacity" : {
+            "type" : "integer"
+          },
+          "enabled" : {
+            "type" : "boolean"
+          },
+          "experts" : {
+            "type" : "object",
+            "additionalProperties" : {
+              "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditExpertSchema"
+            }
+          },
+          "queueCapacity" : {
+            "type" : "integer"
+          },
+          "reader" : {
+            "type" : "string"
+          },
+          "sinks" : {
+            "type" : "array",
+            "items" : {
+              "type" : "string"
+            }
+          }
+        }
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditedEvaluationDeclarationSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "audit" : {
+            "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$AuditSchema"
+          },
+          "evaluation" : {
+            "type" : "object",
+            "additionalProperties" : {
+              "$ref" : "#/items/definitions/org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$EvaluationSchema"
+            }
+          },
+          "expert" : {
+            "type" : "string"
+          },
+          "state" : {
+            "type" : "string"
+          }
+        },
+        "required" : [ "audit", "evaluation" ]
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$DeclarationSchema" : {
+        "type" : "object",
+        "additionalProperties" : false,
+        "properties" : {
+          "expert" : {
+            "type" : "string"
+          },
+          "state" : {
+            "type" : "string"
+          }
+        }
+      },
+      "org.apache.camel.semantic.yaml.SemanticDefinitionDeserializer$EvaluationDeclarationSchema" : {
         "type" : "object",
         "additionalProperties" : false,
         "properties" : {
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/test/java/org/apache/camel/dsl/yaml/SemanticEvaluationTest.java b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/test/java/org/apache/camel/dsl/yaml/SemanticEvaluationTest.java
index d40c0c3c2c18..31609caf5096 100644
--- a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/test/java/org/apache/camel/dsl/yaml/SemanticEvaluationTest.java
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/test/java/org/apache/camel/dsl/yaml/SemanticEvaluationTest.java
@@ -30,12 +30,14 @@ import org.apache.camel.dsl.yaml.common.exception.YamlDeserializationException;
 import org.apache.camel.dsl.yaml.support.YamlTestSupport;
 import org.apache.camel.language.semantic.SemanticLanguage;
 import org.apache.camel.semantic.SemanticAdapter;
+import org.apache.camel.semantic.SemanticAuditQuery;
 import org.apache.camel.semantic.SemanticEvaluation;
 import org.apache.camel.semantic.SemanticEvaluations;
 import org.apache.camel.semantic.SemanticExpert;
 import org.apache.camel.semantic.SemanticOperation;
 import org.apache.camel.semantic.SemanticParameter;
 import org.apache.camel.semantic.SemanticResult;
+import org.apache.camel.semantic.internal.SemanticAuditService;
 import org.apache.camel.spi.Resource;
 import org.apache.camel.support.DefaultExchange;
 import org.apache.camel.support.PluginHelper;
@@ -110,6 +112,72 @@ class SemanticEvaluationTest extends YamlTestSupport {
         }
     }
 
+    @Test
+    void auditSchemaAndDecisionBeanRecordOnlyTheEnabledExpert() throws Exception {
+        loadRoutes("""
+                - beans:
+                  - name: security
+                    type: org.apache.camel.dsl.yaml.SemanticEvaluationTest$SecurityExpert
+                  - name: decisions
+                    type: org.apache.camel.dsl.yaml.SemanticEvaluationTest$SecurityExpert
+                  - name: recordBlocked
+                    type: org.apache.camel.semantic.SemanticAuditDecision
+                    properties:
+                      fields:
+                        action: block
+                        operation: tools/call
+                        target: support-request
+                        reasonCode: prompt_injection
+                - semantic:
+                    audit:
+                      enabled: true
+                      experts:
+                        security: {enabled: true}
+                        decisions: {enabled: false}
+                      sinks: [memory]
+                      reader: memory
+                      capacity: 10
+                      queueCapacity: 10
+                    evaluation:
+                      screenPrompt: {expert: security, operation: injection}
+                      excluded: {expert: decisions, operation: injection}
+                - route:
+                    from:
+                      uri: direct:audit
+                      steps:
+                        - setHeader:
+                            name: ignored
+                            expression:
+                              language:
+                                language: semantic
+                                expression: ref:excluded
+                        - choice:
+                            when:
+                              - expression:
+                                  language:
+                                    language: semantic
+                                    expression: ref:screenPrompt
+                                steps:
+                                  - process:
+                                      ref: recordBlocked
+                                  - to: mock:blocked
+                """);
+        context.start();
+        context.getEndpoint("mock:blocked", MockEndpoint.class).expectedMessageCount(1);
+        try (var template = context.createProducerTemplate()) {
+            template.sendBody("direct:audit", "injection attempt");
+        }
+        MockEndpoint.assertIsSatisfied(context);
+        var audit = SemanticAuditService.get(context);
+        var query = new SemanticAuditQuery(Map.of(), null, null, 10);
+        audit.stop();
+        var records = audit.getReader().query(query).getRecords();
+        assertThat(records).hasSize(2);
+        assertThat(records.get(0).text("action")).isEqualTo("block");
+        assertThat(records.get(0).toMap().get("evidence")).isEqualTo(List.of(records.get(1).getEventId()));
+        assertThat(records.get(1).getExpert()).isEqualTo("security");
+    }
+
     private static String declarations(String state) {
         return """
                 - semantic: