fix(agent,channels): receipts integration test + drop duplicate footer surface

Addresses @WareWolf-MoonWall's review on zeroclaw-labs#6214 (29a779b).

🔴 Add `process_channel_message_renders_trailing_tool_receipts_block_when_enabled`
in `crates/zeroclaw-channels/src/orchestrator/mod.rs::tests` that runs the
full activated path (Some<ReceiptGenerator> + show_receipts_in_response=true)
and asserts the mock channel receives a second send carrying the documented
`---\nTool receipts:` separator and a valid `zc-receipt-*` token tied to the
tool name. Plus a paired `_omits_receipts_block_when_disabled` test
asserting the toggle actually gates the second send.

These tests required `AutonomyLevel::Full` + an explicit
`auto_approve.push("mock_price")` so mock_price actually reaches
`execute_one_tool` — the existing `process_channel_message_*` tests in
this file pass under default Supervised because `ToolCallingProvider`
returns the BTC reply regardless of whether the tool ran (the LLM only
needs to see a `[Tool results]` user message — even a denied/cancelled
payload triggers the canned response). Receipts only generate on the
actual execute path, so the gate has to be open here.

Drop `append_receipt_footer` from `crates/zeroclaw-runtime/src/agent/loop_.rs`
and its two call sites (the `_omits_receipts_block_when_disabled` test
exposed the bug that surfaced it). Pre-fix, the footer mechanism
appended a `---\nTool receipts:\n...` block to the agent's response text
*regardless* of `show_receipts_in_response`, while the orchestrator
*also* sent the same content as a separate channel message *gated* on
the toggle — so:

  show_receipts_in_response = true  → footer + separate block (duplicate)
  show_receipts_in_response = false → footer only (toggle ignored)

Both modes were wrong. The orchestrator's separate-message render is
the design Wolf's review expects (and matches the original PR body), so
keep that path and remove the footer entirely. The
`[receipt: ...]` markers on individual tool results in history are
*kept* — those are how the LLM echoes receipts when the system-prompt
addendum is active. Their corresponding tests live in
`agent::tool_receipts::tests` and are unaffected.

🔵 Replace `let _ = channel.send(...)` for the receipts block with a
`tracing::warn!` on `Err(e)`. The block is the operator-facing audit
surface for the feature; a dropped send must leave a log signal rather
than silently disappear.

🔵 Make the `collected_receipts` arg to `run_tool_call_loop` conditional
on `ctx.receipt_generator.is_some()` instead of unconditional `Some(&...)`.
Inside the loop the collector is only written to when the generator is
also Some, so behaviour is unchanged — the explicit `.map(|_| ...)`
just makes the "collector is meaningful only when generator is active"
relationship visible at the call site.

Author: singlerider

crates/zeroclaw-channels/src/orchestrator/mod.rs

@@ -3190,7 +3190,12 @@ async fn process_channel_message(
                         None, // shared_budget
                         target_channel.as_deref(),
                         ctx.receipt_generator.as_ref(),
-                        Some(&tool_receipts_collector),
+                        // Collector is meaningful only when the generator is
+                        // active. Pass None when receipts are disabled so the
+                        // call site reflects that coupling explicitly.
+                        ctx.receipt_generator
+                            .as_ref()
+                            .map(|_| &tool_receipts_collector),
                     ),
                     ),
                     ),
@@ -3517,13 +3522,22 @@ async fn process_channel_message(
                     eprintln!("  ❌ Failed to reply on {}: {e}", channel.name());
                 }
                 // Send tool receipts as a separate message in the same thread.
-                if let Some(ref block) = receipts_block {
-                    let _ = channel
+                // The block is the operator-facing audit surface for the feature,
+                // so a dropped send must leave a log signal rather than silently
+                // disappear.
+                if let Some(ref block) = receipts_block
+                    && let Err(e) = channel
                         .send(
                             &SendMessage::new(block, &msg.reply_target)
                                 .in_thread(msg.thread_ts.clone()),
                         )
-                        .await;
+                        .await
+                {
+                    tracing::warn!(
+                        channel = channel.name(),
+                        error = %e,
+                        "failed to send tool receipts block"
+                    );
                 }
             }
         }
@@ -7344,6 +7358,252 @@ BTC is currently around $65,000 based on latest tool output."#
         assert!(!reply.contains("mock_price"));
     }
 
+    #[tokio::test]
+    async fn process_channel_message_renders_trailing_tool_receipts_block_when_enabled() {
+        // Activated path: a real ReceiptGenerator + show_receipts_in_response=true
+        // must produce a second send carrying the "Tool receipts:" block with a
+        // valid zc-receipt-* token. Pre-#6214 this was dead code from the test
+        // suite because every ChannelRuntimeContext literal pinned the feature
+        // off; this test guards the integration so a regression in the block
+        // render or send call surfaces in CI rather than in production.
+        let channel_impl = Arc::new(RecordingChannel::default());
+        let channel: Arc<dyn Channel> = channel_impl.clone();
+
+        let mut channels_by_name = HashMap::new();
+        channels_by_name.insert(channel.name().to_string(), channel);
+
+        let runtime_ctx = Arc::new(ChannelRuntimeContext {
+            channels_by_name: Arc::new(channels_by_name),
+            provider: Arc::new(ToolCallingProvider),
+            default_provider: Arc::new("test-provider".to_string()),
+            memory: Arc::new(NoopMemory),
+            tools_registry: Arc::new(vec![Box::new(MockPriceTool)]),
+            observer: Arc::new(NoopObserver),
+            system_prompt: Arc::new("test-system-prompt".to_string()),
+            model: Arc::new("test-model".to_string()),
+            temperature: 0.0,
+            auto_save_memory: false,
+            max_tool_iterations: 10,
+            min_relevance_score: 0.0,
+            conversation_histories: Arc::new(Mutex::new(lru::LruCache::new(
+                std::num::NonZeroUsize::new(MAX_CONVERSATION_SENDERS).unwrap(),
+            ))),
+            pending_new_sessions: Arc::new(Mutex::new(HashSet::new())),
+            provider_cache: Arc::new(Mutex::new(HashMap::new())),
+            route_overrides: Arc::new(Mutex::new(HashMap::new())),
+            api_key: None,
+            api_url: None,
+            reliability: Arc::new(zeroclaw_config::schema::ReliabilityConfig::default()),
+            provider_runtime_options: zeroclaw_providers::ProviderRuntimeOptions::default(),
+            workspace_dir: Arc::new(std::env::temp_dir()),
+            prompt_config: Arc::new(zeroclaw_config::schema::Config::default()),
+            message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
+            interrupt_on_new_message: InterruptOnNewMessageConfig {
+                telegram: false,
+                slack: false,
+                discord: false,
+                mattermost: false,
+                matrix: false,
+            },
+            non_cli_excluded_tools: Arc::new(Vec::new()),
+            // Full autonomy + auto-approve mock_price so the loop actually
+            // reaches execute_one_tool. The other tests in this file pass
+            // under Supervised because ToolCallingProvider returns the BTC
+            // reply regardless of whether the tool ran (the LLM only needs
+            // to see a `[Tool results]` user message — even a "denied"
+            // payload triggers the deterministic response). Receipts only
+            // generate on the actual execute path, so we need the gate
+            // open here.
+            autonomy_level: AutonomyLevel::Full,
+            tool_call_dedup_exempt: Arc::new(Vec::new()),
+            multimodal: zeroclaw_config::schema::MultimodalConfig::default(),
+            media_pipeline: zeroclaw_config::schema::MediaPipelineConfig::default(),
+            transcription_config: zeroclaw_config::schema::TranscriptionConfig::default(),
+            hooks: None,
+            model_routes: Arc::new(Vec::new()),
+            query_classification: zeroclaw_config::schema::QueryClassificationConfig::default(),
+            ack_reactions: true,
+            show_tool_calls: true,
+            session_store: None,
+            approval_manager: Arc::new(ApprovalManager::for_non_interactive(&{
+                let mut autonomy = zeroclaw_config::schema::AutonomyConfig::default();
+                autonomy.level = zeroclaw_config::autonomy::AutonomyLevel::Full;
+                autonomy.auto_approve.push("mock_price".to_string());
+                autonomy
+            })),
+            activated_tools: None,
+            cost_tracking: None,
+            pacing: zeroclaw_config::schema::PacingConfig::default(),
+            max_tool_result_chars: 0,
+            context_token_budget: 0,
+            debouncer: Arc::new(zeroclaw_infra::debounce::MessageDebouncer::new(
+                Duration::ZERO,
+            )),
+            receipt_generator: Some(
+                zeroclaw_runtime::agent::tool_receipts::ReceiptGenerator::new(),
+            ),
+            show_receipts_in_response: true,
+        });
+
+        process_channel_message(
+            runtime_ctx,
+            zeroclaw_api::channel::ChannelMessage {
+                id: "msg-1".to_string(),
+                sender: "alice".to_string(),
+                reply_target: "chat-42".to_string(),
+                content: "What is the BTC price now?".to_string(),
+                channel: "test-channel".to_string(),
+                timestamp: 1,
+                thread_ts: None,
+                interruption_scope_id: None,
+                attachments: vec![],
+            },
+            CancellationToken::new(),
+        )
+        .await;
+
+        let sent_messages = channel_impl.sent_messages.lock().await;
+        // Two sends: the model's reply and the trailing receipts block.
+        assert!(
+            sent_messages.len() >= 2,
+            "expected at least 2 sends (reply + receipts block), got {}: {:?}",
+            sent_messages.len(),
+            sent_messages
+        );
+
+        let receipts_message = sent_messages
+            .iter()
+            .find(|m| m.contains("Tool receipts:"))
+            .unwrap_or_else(|| {
+                panic!(
+                    "no `Tool receipts:` send found; got {:?}",
+                    sent_messages.as_slice()
+                )
+            });
+        assert!(
+            receipts_message.starts_with("chat-42:"),
+            "receipts block must be sent to the same reply target as the agent reply, got {receipts_message}"
+        );
+        assert!(
+            receipts_message.contains("---\nTool receipts:"),
+            "receipts block must be prefixed with the documented `---\\nTool receipts:` separator, got {receipts_message}"
+        );
+        assert!(
+            receipts_message.contains("zc-receipt-"),
+            "receipts block must carry at least one zc-receipt-* HMAC token (proves the generator actually ran), got {receipts_message}"
+        );
+        assert!(
+            receipts_message.contains("mock_price"),
+            "receipts block should name the tool that produced the receipt, got {receipts_message}"
+        );
+    }
+
+    #[tokio::test]
+    async fn process_channel_message_omits_receipts_block_when_disabled() {
+        // Backward-compat: with show_receipts_in_response=false (default), no
+        // trailing receipts message is sent — even when a generator is active
+        // and the loop ran tools. This is the path every other test relies on
+        // implicitly; assert it once explicitly.
+        let channel_impl = Arc::new(RecordingChannel::default());
+        let channel: Arc<dyn Channel> = channel_impl.clone();
+
+        let mut channels_by_name = HashMap::new();
+        channels_by_name.insert(channel.name().to_string(), channel);
+
+        let runtime_ctx = Arc::new(ChannelRuntimeContext {
+            channels_by_name: Arc::new(channels_by_name),
+            provider: Arc::new(ToolCallingProvider),
+            default_provider: Arc::new("test-provider".to_string()),
+            memory: Arc::new(NoopMemory),
+            tools_registry: Arc::new(vec![Box::new(MockPriceTool)]),
+            observer: Arc::new(NoopObserver),
+            system_prompt: Arc::new("test-system-prompt".to_string()),
+            model: Arc::new("test-model".to_string()),
+            temperature: 0.0,
+            auto_save_memory: false,
+            max_tool_iterations: 10,
+            min_relevance_score: 0.0,
+            conversation_histories: Arc::new(Mutex::new(lru::LruCache::new(
+                std::num::NonZeroUsize::new(MAX_CONVERSATION_SENDERS).unwrap(),
+            ))),
+            pending_new_sessions: Arc::new(Mutex::new(HashSet::new())),
+            provider_cache: Arc::new(Mutex::new(HashMap::new())),
+            route_overrides: Arc::new(Mutex::new(HashMap::new())),
+            api_key: None,
+            api_url: None,
+            reliability: Arc::new(zeroclaw_config::schema::ReliabilityConfig::default()),
+            provider_runtime_options: zeroclaw_providers::ProviderRuntimeOptions::default(),
+            workspace_dir: Arc::new(std::env::temp_dir()),
+            prompt_config: Arc::new(zeroclaw_config::schema::Config::default()),
+            message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
+            interrupt_on_new_message: InterruptOnNewMessageConfig {
+                telegram: false,
+                slack: false,
+                discord: false,
+                mattermost: false,
+                matrix: false,
+            },
+            non_cli_excluded_tools: Arc::new(Vec::new()),
+            // Match the enabled-test setup so the tool actually runs; the
+            // assertion below proves the receipt-block send is gated on
+            // `show_receipts_in_response` and not on whether the loop saw
+            // any receipts.
+            autonomy_level: AutonomyLevel::Full,
+            tool_call_dedup_exempt: Arc::new(Vec::new()),
+            multimodal: zeroclaw_config::schema::MultimodalConfig::default(),
+            media_pipeline: zeroclaw_config::schema::MediaPipelineConfig::default(),
+            transcription_config: zeroclaw_config::schema::TranscriptionConfig::default(),
+            hooks: None,
+            model_routes: Arc::new(Vec::new()),
+            query_classification: zeroclaw_config::schema::QueryClassificationConfig::default(),
+            ack_reactions: true,
+            show_tool_calls: true,
+            session_store: None,
+            approval_manager: Arc::new(ApprovalManager::for_non_interactive(&{
+                let mut autonomy = zeroclaw_config::schema::AutonomyConfig::default();
+                autonomy.level = zeroclaw_config::autonomy::AutonomyLevel::Full;
+                autonomy.auto_approve.push("mock_price".to_string());
+                autonomy
+            })),
+            activated_tools: None,
+            cost_tracking: None,
+            pacing: zeroclaw_config::schema::PacingConfig::default(),
+            max_tool_result_chars: 0,
+            context_token_budget: 0,
+            debouncer: Arc::new(zeroclaw_infra::debounce::MessageDebouncer::new(
+                Duration::ZERO,
+            )),
+            receipt_generator: Some(
+                zeroclaw_runtime::agent::tool_receipts::ReceiptGenerator::new(),
+            ),
+            show_receipts_in_response: false,
+        });
+
+        process_channel_message(
+            runtime_ctx,
+            zeroclaw_api::channel::ChannelMessage {
+                id: "msg-1".to_string(),
+                sender: "alice".to_string(),
+                reply_target: "chat-42".to_string(),
+                content: "What is the BTC price now?".to_string(),
+                channel: "test-channel".to_string(),
+                timestamp: 1,
+                thread_ts: None,
+                interruption_scope_id: None,
+                attachments: vec![],
+            },
+            CancellationToken::new(),
+        )
+        .await;
+
+        let sent_messages = channel_impl.sent_messages.lock().await;
+        assert!(
+            !sent_messages.iter().any(|m| m.contains("Tool receipts:")),
+            "no receipts block must be sent when show_receipts_in_response=false; got {:?}",
+            sent_messages.as_slice()
+        );
+    }
+
     #[tokio::test]
     async fn process_channel_message_telegram_does_not_persist_tool_summary_prefix() {
         let channel_impl = Arc::new(TelegramRecordingChannel::default());

crates/zeroclaw-runtime/src/agent/loop_.rs

@@ -802,31 +802,6 @@ fn maybe_inject_channel_delivery_defaults(
 //   • the cancellation token fires (external abort).
 
 /// Append a receipt footer to the response text if any receipts were collected.
-///
-/// Format:
-/// ```text
-/// \n\n---\nTool receipts:\n  shell: zc-receipt-...\n  web_search: zc-receipt-...
-/// ```
-pub fn append_receipt_footer(
-    response: String,
-    collected_receipts: Option<&std::sync::Mutex<Vec<String>>>,
-) -> String {
-    let Some(store) = collected_receipts else {
-        return response;
-    };
-    let Ok(receipts) = store.lock() else {
-        return response;
-    };
-    if receipts.is_empty() {
-        return response;
-    }
-    let mut footer = format!("{response}\n\n---\nTool receipts:");
-    for entry in receipts.iter() {
-        footer.push_str(&format!("\n  {entry}"));
-    }
-    footer
-}
-
 /// Execute a single turn of the agent loop: send messages, parse tool calls,
 /// execute tools, and loop until the LLM produces a final text response.
 #[allow(clippy::too_many_arguments)]
@@ -1466,10 +1441,7 @@ pub async fn run_tool_call_loop(
             }
 
             history.push(ChatMessage::assistant(response_text.clone()));
-            return Ok(append_receipt_footer(
-                accumulated_display_text,
-                collected_receipts,
-            ));
+            return Ok(accumulated_display_text);
         }
 
         // Accumulate text from this iteration (tool calls present, loop continues).
@@ -2023,10 +1995,7 @@ pub async fn run_tool_call_loop(
                 anyhow::bail!("Agent exceeded maximum tool iterations ({max_iterations})")
             }
             accumulated_display_text.push_str(&text);
-            Ok(append_receipt_footer(
-                accumulated_display_text,
-                collected_receipts,
-            ))
+            Ok(accumulated_display_text)
         }
         Err(e) => {
             tracing::warn!(error = %e, "Final summary LLM call failed, bailing");
@@ -7522,44 +7491,4 @@ Let me check the result."#;
 
         assert_eq!(result, "ok");
     }
-
-    // ── append_receipt_footer tests ──────────────────────────────
-
-    #[test]
-    fn receipt_footer_empty_receipts_unchanged() {
-        let store = std::sync::Mutex::new(Vec::<String>::new());
-        let result = super::append_receipt_footer("Hello world".to_string(), Some(&store));
-        assert_eq!(result, "Hello world");
-    }
-
-    #[test]
-    fn receipt_footer_none_store_unchanged() {
-        let result = super::append_receipt_footer("Hello world".to_string(), None);
-        assert_eq!(result, "Hello world");
-    }
-
-    #[test]
-    fn receipt_footer_single_receipt() {
-        let store = std::sync::Mutex::new(vec!["shell: zc-receipt-1234567890-abcdef".to_string()]);
-        let result = super::append_receipt_footer("The date is Monday.".to_string(), Some(&store));
-        assert_eq!(
-            result,
-            "The date is Monday.\n\n---\nTool receipts:\n  shell: zc-receipt-1234567890-abcdef"
-        );
-    }
-
-    #[test]
-    fn receipt_footer_multiple_receipts() {
-        let store = std::sync::Mutex::new(vec![
-            "shell: zc-receipt-100-aaa".to_string(),
-            "web_search: zc-receipt-200-bbb".to_string(),
-            "file_read: zc-receipt-300-ccc".to_string(),
-        ]);
-        let result = super::append_receipt_footer("Done.".to_string(), Some(&store));
-        let expected = "Done.\n\n---\nTool receipts:\
-            \n  shell: zc-receipt-100-aaa\
-            \n  web_search: zc-receipt-200-bbb\
-            \n  file_read: zc-receipt-300-ccc";
-        assert_eq!(result, expected);
-    }
 }