chore: promote staging to staging-promote/e0f393bf-23105705354 (2026-03-16 21:11 UTC)

[ironclaw-ci]

Auto-promotion from staging CI

Batch range: 63a23550d6b485de6eb3b9a8aefeee47de569ddd..878a67cdb6608527c1bf6ac412180fc1fb2e56bc
Promotion branch: staging-promote/878a67cd-23166116689
Base: staging-promote/e0f393bf-23105705354
Triggered by: Staging CI batch at 2026-03-16 21:11 UTC

Commits in this batch (2):

• 971b4c2 fix: web/CLI routine mutations do not refresh live event trigger cache (fix: web/CLI routine mutations do not refresh live event trigger cache #1255)
• 878a67c Refactor owner scope across channels and fix default routing fallback (Refactor owner scope across channels and fix default routing fallback #1151)

Current commits in this promotion (14)

Current base: staging-promote/e0f393bf-23105705354
Current head: staging-promote/878a67cd-23166116689
Current range: origin/staging-promote/e0f393bf-23105705354..origin/staging-promote/878a67cd-23166116689

• a677b20 chore: promote staging to main (2026-03-10 15:19 UTC) (chore: promote staging to main (2026-03-10 15:19 UTC) #865)
• 6a1301b feat(i18n): Add internationalization support with Chinese and English translations (feat(i18n): Add internationalization support with Chinese and English translations #929) (chore: promote staging to main (2026-03-11 15:17 UTC) #950)
• 7e8c0fb chore: release v0.18.0 (chore: release v0.18.0 #885)
• 8391415 chore: update WASM artifact SHA256 checksums [skip ci] (chore: update WASM artifact checksums and version-pinned URLs #954)
• 8c2131d feat(embeddings): add EMBEDDING_BASE_URL for OpenAI-compatible embedding providers (feat(embeddings): add EMBEDDING_BASE_URL for OpenAI-compatible embedding providers #1082)
• ca6d9f6 fix(registry): bump versions for github, web-search, and discord extensions
• c4e098d Fix subagent monitor events being treated as user input (Fix subagent monitor events being treated as user input #1173)
• 877f117 feat(transcription): add Chat Completions API provider for audio transcription (feat(transcription): add Chat Completions API provider for audio transcription #1130)
• 0245c0f feat(orchestrator): read ORCHESTRATOR_PORT env var for configurable API port (feat(orchestrator): read ORCHESTRATOR_PORT env var for configurable API port #1113)
• de214c2 feat: add LLM_CHEAP_MODEL for generic smart routing across all backends (feat: add LLM_CHEAP_MODEL for generic smart routing across all backends #1081)
• 971b4c2 fix: web/CLI routine mutations do not refresh live event trigger cache (fix: web/CLI routine mutations do not refresh live event trigger cache #1255)
• 878a67c Refactor owner scope across channels and fix default routing fallback (Refactor owner scope across channels and fix default routing fallback #1151)
• fc18064 fix: resolve merge conflict fallout and missing config fields
• 026beb0 fix: cover staging CI all-features and routine batch regressions (fix: cover staging CI all-features and routine batch regressions #1256)

Auto-updated by staging promotion metadata workflow

Waiting for gates:

• Tests: pending
• E2E: pending
• Claude Code review: pending (will post comments on this PR)

---

Auto-created by staging-ci workflow

[claude]

Code review

Found 14 issues:

1. [CRITICAL:92] Telegram forum thread_id semantics changed without migration tests - thread_id now uses only chat_id instead of chat_id:topic_id format, losing topic distinction.

   ironclaw/channels-src/telegram/src/lib.rs

   Lines 1903 to 1930 in 878a67c

   	let metadata = TelegramMessageMetadata {
   	chat_id: message.chat.id,
   	message_id: message.message_id,
   	user_id: from.id,
   	is_private,
   	message_thread_id: message.message_thread_id,
   	};
   	let metadata_json = serde_json::to_string(&metadata).unwrap_or_else(|_| "{}".to_string());
   	let bot_username = channel_host::workspace_read(BOT_USERNAME_PATH).unwrap_or_default();
   	let content_to_emit = match content_to_emit_for_agent(
   	&content,
   	if bot_username.is_empty() {
   	None
   	} else {
   	Some(bot_username.as_str())
   	},
   	) {
   	Some(value) => value,
   	// Allow attachment-only messages even without text
   	None if !attachments.is_empty() => String::new(),
   	None => return,
   	};
   	// Emit the message to the agent
   	channel_host::emit_message(&EmittedMessage {
   	user_id: from.id.to_string(),

2. [HIGH:85] Test coverage regression - Telegram forum topic tests deleted without integration test validating migration path

   ironclaw/channels-src/telegram/src/lib.rs

   Lines 2726 to 2766 in 878a67c

   	filename: filename.map(|s| s.to_string()),
   	size_bytes: Some(1024),
   	source_url: None,
   	storage_key: None,
   	extracted_text: None,
   	extras_json: String::new(),
   	};
   	// PDFs and Office docs should be downloaded
   	assert!(is_downloadable_document(&make(
   	"application/pdf",
   	Some("report.pdf")
   	)));
   	assert!(is_downloadable_document(&make(
   	"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
   	Some("doc.docx"),
   	)));
   	assert!(is_downloadable_document(&make(
   	"text/plain",
   	Some("notes.txt")
   	)));
   	// Voice, image, audio, video should NOT be downloaded
   	assert!(!is_downloadable_document(&make(
   	"audio/ogg",
   	Some("voice_123.ogg")
   	)));
   	assert!(!is_downloadable_document(&make("image/jpeg", None)));
   	assert!(!is_downloadable_document(&make(
   	"audio/mpeg",
   	Some("song.mp3")
   	)));
   	assert!(!is_downloadable_document(&make(
   	"video/mp4",
   	Some("clip.mp4")
   	)));
   	}
   	#[test]
   	fn test_max_download_size_constant() {
   	// Verify the constant is 20 MB, matching the Slack channel limit

3. [HIGH:78] Routine notification fallback logic may be inverted - should_fallback_routine_notification returns false for MissingRoutingTarget when it should skip fallback

   ironclaw/src/agent/routine_engine.rs

   Lines 809 to 835 in 878a67c

   	Err(e) => {
   	tracing::warn!(routine = %routine.name, "Failed to get system prompt: {}", e);
   	String::new()
   	}
   	};
   	// Determine max_tokens from model metadata with fallback
   	let effective_max_tokens = match ctx.llm.model_metadata().await {
   	Ok(meta) => {
   	let from_api = meta.context_length.map(|ctx| ctx / 2).unwrap_or(max_tokens);
   	from_api.max(max_tokens)
   	}
   	Err(_) => max_tokens,
   	};
   	// If tools are enabled (both globally and per-routine), use the tool execution loop
   	if use_tools && ctx.config.lightweight_tools_enabled {
   	execute_lightweight_with_tools(
   	ctx,
   	routine,
   	&system_prompt,
   	&full_prompt,
   	effective_max_tokens,
   	max_tool_rounds,
   	)
   	.await
   	} else {

4. [HIGH:78] Unsafe unwrap in test code - Multiple .unwrap() and .expect() calls violating CLAUDE.md https://github.com/nearai/ironclaw/blob/878a67cdb6608527c1bf6ac412180fc1fb2e56bc/src/channels/http.rs#L1440-L1462

5. [MEDIUM:72] broadcast_all uses string-based routing instead of enums, missing type-driven design

   ironclaw/src/channels/wasm/router.rs

   Lines 50 to 100 in 878a67c

   	impl WasmChannelRouter {
   	/// Create a new router.
   	pub fn new() -> Self {
   	Self {
   	channels: RwLock::new(HashMap::new()),
   	path_to_channel: RwLock::new(HashMap::new()),
   	secrets: RwLock::new(HashMap::new()),
   	secret_headers: RwLock::new(HashMap::new()),
   	signature_keys: RwLock::new(HashMap::new()),
   	hmac_secrets: RwLock::new(HashMap::new()),
   	}
   	}
   	/// Register a channel with its endpoints.
   	///
   	/// # Arguments
   	/// * `channel` - The WASM channel to register
   	/// * `endpoints` - HTTP endpoints to register for this channel
   	/// * `secret` - Optional webhook secret for validation
   	/// * `secret_header` - Optional HTTP header name for secret validation
   	/// (e.g., "X-Telegram-Bot-Api-Secret-Token"). Defaults to "X-Webhook-Secret".
   	pub async fn register(
   	&self,
   	channel: Arc<WasmChannel>,
   	endpoints: Vec<RegisteredEndpoint>,
   	secret: Option<String>,
   	secret_header: Option<String>,
   	) {
   	let name = channel.channel_name().to_string();
   	// Store the channel
   	self.channels.write().await.insert(name.clone(), channel);
   	// Register path mappings
   	let mut path_map = self.path_to_channel.write().await;
   	for endpoint in endpoints {
   	path_map.insert(endpoint.path.clone(), name.clone());
   	tracing::info!(
   	channel = %name,
   	path = %endpoint.path,
   	methods = ?endpoint.methods,
   	"Registered WASM channel HTTP endpoint"
   	);
   	}
   	// Store secret if provided
   	if let Some(s) = secret {
   	self.secrets.write().await.insert(name.clone(), s);
   	}

6. [MEDIUM:68] DRY violation - resolve_channel_host_credentials called 6+ times with same owner_scope_id pattern but lacks trait abstraction

7. [MEDIUM:65] Owner scope migration uses magic string 'default' instead of explicit enum

   ironclaw/src/channels/wasm/wrapper.rs

   Lines 938 to 950 in 878a67c

   	"Restored broadcast metadata from settings"
   	);
   	}
   	Ok(_) => {
   	if self.owner_scope_id != "default" {
   	match store
   	.get_setting("default", &self.broadcast_metadata_key())
   	.await
   	{
   	Ok(Some(serde_json::Value::String(meta))) => {
   	*self.last_broadcast_metadata.write().await = Some(meta);
   	tracing::debug!(
   	channel = %self.name,

8. [MEDIUM:62] HTTP webhook normalize_user_id edge case - (None, Some(_)) marked unreachable but logically possible

   ironclaw/src/channels/http.rs

   Lines 800 to 815 in 878a67c

   	.method("POST")
   	.uri("/webhook")
   	.header("content-type", "application/json")
   	.header("x-hub-signature-256", "not-a-valid-signature")
   	.body(Body::from(serde_json::to_vec(&body).unwrap()))
   	.unwrap();
   	let resp = app.oneshot(req).await.unwrap();
   	assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
   	}
   	#[tokio::test]
   	async fn webhook_deprecated_body_secret_still_works() {
   	let channel = test_channel(Some("test-secret-123"));
   	let _stream = channel.start().await.unwrap();
   	let app = channel.routes();

9. [MEDIUM:62] Inconsistent error handling in Telegram - uses map_err string formatting instead of thiserror

   ironclaw/channels-src/telegram/src/lib.rs

   Lines 100 to 200 in 878a67c

   	/// Sticker.
   	sticker: Option<TelegramSticker>,
   	/// Forum topic ID. Present when the message is sent inside a forum topic.
   	#[serde(default)]
   	message_thread_id: Option<i64>,
   	/// True when this message is sent inside a forum topic.
   	#[serde(default)]
   	is_topic_message: Option<bool>,
   	}
   	/// Telegram PhotoSize object.
   	#[derive(Debug, Deserialize)]
   	struct PhotoSize {
   	file_id: String,
   	file_unique_id: String,
   	width: i32,
   	height: i32,
   	file_size: Option<i64>,
   	}
   	/// Telegram Document object.
   	#[derive(Debug, Deserialize)]
   	struct TelegramDocument {
   	file_id: String,
   	file_unique_id: String,
   	file_name: Option<String>,
   	mime_type: Option<String>,
   	file_size: Option<i64>,
   	}
   	/// Telegram Audio object.
   	#[derive(Debug, Deserialize)]
   	struct TelegramAudio {
   	file_id: String,
   	file_unique_id: String,
   	duration: Option<u32>,
   	file_name: Option<String>,
   	mime_type: Option<String>,
   	file_size: Option<i64>,
   	}
   	/// Telegram Video object.
   	#[derive(Debug, Deserialize)]
   	struct TelegramVideo {
   	file_id: String,
   	file_unique_id: String,
   	duration: Option<u32>,
   	file_name: Option<String>,
   	mime_type: Option<String>,
   	file_size: Option<i64>,
   	}
   	/// Telegram Voice message object.
   	#[derive(Debug, Deserialize)]
   	struct TelegramVoice {
   	file_id: String,
   	file_unique_id: String,
   	duration: u32,
   	mime_type: Option<String>,
   	file_size: Option<i64>,
   	}
   	/// Telegram Sticker object.
   	#[derive(Debug, Deserialize)]
   	struct TelegramSticker {
   	file_id: String,
   	file_unique_id: String,
   	#[serde(rename = "type")]
   	sticker_type: Option<String>,
   	file_size: Option<i64>,
   	}
   	/// Telegram User object.
   	/// https://core.telegram.org/bots/api#user
   	#[derive(Debug, Deserialize)]
   	struct TelegramUser {
   	/// Unique user identifier.
   	id: i64,
   	/// True if this is a bot.
   	is_bot: bool,
   	/// User's first name.
   	first_name: String,
   	/// User's last name.
   	last_name: Option<String>,
   	/// Username (without @).
   	username: Option<String>,
   	}
   	/// Telegram Chat object.
   	/// https://core.telegram.org/bots/api#chat
   	#[derive(Debug, Deserialize)]
   	struct TelegramChat {
   	/// Unique chat identifier.
   	id: i64,

10. [MEDIUM:70] Telegram bot_username read twice - moved inside conditional, reads twice when respond_to_all=false

    ironclaw/channels-src/telegram/src/lib.rs

    Lines 1866 to 1880 in 878a67c

    	}
    	// For group chats, only respond if bot was mentioned or respond_to_all is enabled
    	if !is_private {
    	let respond_to_all = channel_host::workspace_read(RESPOND_TO_ALL_GROUP_PATH)
    	.as_deref()
    	.unwrap_or("false")
    	== "true";
    	if !respond_to_all {
    	let has_command = content.starts_with('/');
    	let bot_username = channel_host::workspace_read(BOT_USERNAME_PATH).unwrap_or_default();
    	let has_bot_mention = if bot_username.is_empty() {
    	content.contains('@')
    	} else {

11. [MEDIUM:60] IncomingMessage builder incomplete - with_owner_id/with_sender_id added but conversation_scope fallback to thread_id lacks documentation

12. [LOW:55] Comment deletion reduces clarity - Telegram API quirk comments removed without updating code

    ironclaw/channels-src/telegram/src/lib.rs

    Lines 729 to 740 in 878a67c

    	TelegramStatusAction::Typing => {
    	// POST /sendChatAction with action "typing"
    	let mut payload = serde_json::json!({
    	"chat_id": metadata.chat_id,
    	"action": "typing"
    	});
    	if let Some(thread_id) = metadata.message_thread_id {
    	payload["message_thread_id"] = serde_json::Value::Number(thread_id.into());
    	}
    	let payload_bytes = match serde_json::to_vec(&payload) {

13. [LOW:50] Test assertion comments inconsistent - 'safety: test-only assertion' not applied uniformly

[claude]

Additional Performance & Production Issues (from Agent 4)

15. [CRITICAL:85] Routine notification forwarder may silently drop notifications if resolve_routine_notification_user() returns None, causing event loss via continue statement

    ironclaw/src/agent/routine_engine.rs

    Lines 790 to 810 in 878a67c

    	if !context_parts.is_empty() {
    	full_prompt.push_str("\n\n---\n\n# Context\n\n");
    	full_prompt.push_str(&context_parts.join("\n\n"));
    	}
    	if let Some(state) = &state_content {
    	full_prompt.push_str("\n\n---\n\n# Previous State\n\n");
    	full_prompt.push_str(state);
    	}
    	full_prompt.push_str(
    	"\n\n---\n\nIf nothing needs attention, reply EXACTLY with: ROUTINE_OK\n\
    	If something needs attention, provide a concise summary.",
    	);
    	// Get system prompt
    	let system_prompt = match ctx.workspace.system_prompt().await {
    	Ok(p) => p,
    	Err(e) => {
    	tracing::warn!(routine = %routine.name, "Failed to get system prompt: {}", e);

16. [HIGH:80] Legacy broadcast metadata migration creates N+1 pattern - load_broadcast_metadata executes secondary database query for every non-default owner_scope on WasmChannel initialization

    ironclaw/src/channels/wasm/wrapper.rs

    Lines 928 to 965 in 878a67c

    	async fn load_broadcast_metadata(&self) {
    	if let Some(ref store) = self.settings_store {
    	match store
    	.get_setting(&self.owner_scope_id, &self.broadcast_metadata_key())
    	.await
    	{
    	Ok(Some(serde_json::Value::String(meta))) => {
    	*self.last_broadcast_metadata.write().await = Some(meta);
    	tracing::debug!(
    	channel = %self.name,
    	"Restored broadcast metadata from settings"
    	);
    	}
    	Ok(_) => {
    	if self.owner_scope_id != "default" {
    	match store
    	.get_setting("default", &self.broadcast_metadata_key())
    	.await
    	{
    	Ok(Some(serde_json::Value::String(meta))) => {
    	*self.last_broadcast_metadata.write().await = Some(meta);
    	tracing::debug!(
    	channel = %self.name,
    	"Restored legacy owner broadcast metadata from default scope"
    	);
    	}
    	Ok(_) => {}
    	Err(e) => {
    	tracing::warn!(
    	channel = %self.name,
    	"Failed to load legacy broadcast metadata: {}",
    	e
    	);
    	}
    	}
    	}
    	}
    	Err(e) => {

17. [HIGH:75] Multiple .clone() calls on response objects in broadcast loops without verifying OutgoingResponse move semantics are optimal

    ironclaw/src/agent/routine_engine.rs

    Line 424 in 878a67c

    }

18. [MEDIUM:70] Missing timeout on load_broadcast_metadata database query - could block channel startup indefinitely

    ironclaw/src/channels/wasm/wrapper.rs

    Lines 928 to 965 in 878a67c

    	async fn load_broadcast_metadata(&self) {
    	if let Some(ref store) = self.settings_store {
    	match store
    	.get_setting(&self.owner_scope_id, &self.broadcast_metadata_key())
    	.await
    	{
    	Ok(Some(serde_json::Value::String(meta))) => {
    	*self.last_broadcast_metadata.write().await = Some(meta);
    	tracing::debug!(
    	channel = %self.name,
    	"Restored broadcast metadata from settings"
    	);
    	}
    	Ok(_) => {
    	if self.owner_scope_id != "default" {
    	match store
    	.get_setting("default", &self.broadcast_metadata_key())
    	.await
    	{
    	Ok(Some(serde_json::Value::String(meta))) => {
    	*self.last_broadcast_metadata.write().await = Some(meta);
    	tracing::debug!(
    	channel = %self.name,
    	"Restored legacy owner broadcast metadata from default scope"
    	);
    	}
    	Ok(_) => {}
    	Err(e) => {
    	tracing::warn!(
    	channel = %self.name,
    	"Failed to load legacy broadcast metadata: {}",
    	e
    	);
    	}
    	}
    	}
    	}
    	Err(e) => {

19. [MEDIUM:65] Fallback routing skips broadcast_all when should_fallback_routine_notification() returns false without backoff - could consume CPU in tight error loop if all channels return MissingRoutingTarget

20. [MEDIUM:60] owner_id.clone() called multiple times in broadcast hot paths - consider Arc or &str

    ironclaw/src/agent/routine_engine.rs

    Lines 313 to 415 in 878a67c

    	// Concurrent run check (using batch-loaded counts)
    	let running_count = concurrent_counts.get(&routine.id).copied().unwrap_or(0);
    	if running_count >= routine.guardrails.max_concurrent as i64 {
    	tracing::debug!(routine = %routine.name, "Skipped: max concurrent reached");
    	continue;
    	}
    	if self.running_count.load(Ordering::Relaxed) >= self.config.max_concurrent_routines {
    	tracing::warn!(routine = %routine.name, "Skipped: global max concurrent reached");
    	continue;
    	}
    	let detail = truncate(&format!("{source}:{event_type}"), 200);
    	self.spawn_fire(routine.clone(), "system_event", Some(detail));
    	fired += 1;
    	}
    	fired
    	}
    	/// Check all due cron routines and fire them. Called by the cron ticker.
    	pub async fn check_cron_triggers(&self) {
    	let routines = match self.store.list_due_cron_routines().await {
    	Ok(r) => r,
    	Err(e) => {
    	tracing::error!("Failed to load due cron routines: {}", e);
    	return;
    	}
    	};
    	for routine in routines {
    	if self.running_count.load(Ordering::Relaxed) >= self.config.max_concurrent_routines {
    	tracing::warn!("Global max concurrent routines reached, skipping remaining");
    	break;
    	}
    	if !self.check_cooldown(&routine) {
    	continue;
    	}
    	if !self.check_concurrent(&routine).await {
    	continue;
    	}
    	let detail = if let Trigger::Cron { ref schedule, .. } = routine.trigger {
    	Some(schedule.clone())
    	} else {
    	None
    	};
    	self.spawn_fire(routine, "cron", detail);
    	}
    	}
    	/// Fire a routine manually (from tool call or CLI).
    	///
    	/// Bypasses cooldown checks (those only apply to cron/event triggers).
    	/// Still enforces enabled check and concurrent run limit.
    	pub async fn fire_manual(
    	&self,
    	routine_id: Uuid,
    	user_id: Option<&str>,
    	) -> Result<Uuid, RoutineError> {
    	let routine = self
    	.store
    	.get_routine(routine_id)
    	.await
    	.map_err(|e| RoutineError::Database {
    	reason: e.to_string(),
    	})?
    	.ok_or(RoutineError::NotFound { id: routine_id })?;
    	// Enforce ownership when a user_id is provided (gateway calls).
    	if let Some(uid) = user_id
    	&& routine.user_id != uid
    	{
    	return Err(RoutineError::NotAuthorized { id: routine_id });
    	}
    	if !routine.enabled {
    	return Err(RoutineError::Disabled {
    	name: routine.name.clone(),
    	});
    	}
    	if !self.check_concurrent(&routine).await {
    	return Err(RoutineError::MaxConcurrent {
    	name: routine.name.clone(),
    	});
    	}
    	let run_id = Uuid::new_v4();
    	let run = RoutineRun {
    	id: run_id,
    	routine_id: routine.id,
    	trigger_type: "manual".to_string(),
    	trigger_detail: None,
    	started_at: Utc::now(),
    	completed_at: None,
    	status: RunStatus::Running,
    	result_summary: None,
    	tokens_used: None,

21. [LOW:50] Many .unwrap_or_else() on workspace_read() calls without timeout on blocking I/O operations

    ironclaw/channels-src/telegram/src/lib.rs

    Lines 1745 to 1800 in 878a67c

    	}
    	}
    	/// Process a single message.
    	fn handle_message(message: TelegramMessage) {
    	// Extract attachments from media fields (pure data mapping, no host calls)
    	let mut attachments = extract_attachments(&message);
    	// Download and store voice attachments for host-side transcription
    	download_and_store_voice(&attachments);
    	// Download and store image attachments for host-side vision pipeline
    	download_and_store_images(&attachments);
    	// Download and store document attachments for host-side text extraction
    	download_and_store_documents(&mut attachments);
    	// Use text or caption (for media messages)
    	let has_voice = message.voice.is_some();
    	let content = message
    	.text
    	.filter(|t| !t.is_empty())
    	.or_else(|| message.caption.filter(|c| !c.is_empty()))
    	.unwrap_or_else(|| {
    	if has_voice {
    	"[Voice note]".to_string()
    	} else {
    	String::new()
    	}
    	});
    	// Allow messages with attachments even if text content is empty
    	if content.is_empty() && attachments.is_empty() {
    	return;
    	}
    	// Skip messages without a sender (channel posts)
    	let from = match message.from {
    	Some(f) => f,
    	None => return,
    	};
    	// Skip bot messages to avoid loops
    	if from.is_bot {
    	return;
    	}
    	let is_private = message.chat.chat_type == "private";
    	let owner_id = channel_host::workspace_read(OWNER_ID_PATH)
    	.filter(|s| !s.is_empty())
    	.and_then(|s| s.parse::<i64>().ok());
    	let is_owner = owner_id == Some(from.id);
    	if !is_owner {
    	// Non-owner senders remain guests. Apply authorization based on

[claude]

Security & Safety Issues (from Agent 1)

22. [CRITICAL:78] Routine.user_id not explicitly set from job context during creation - only scope filter added. The routine_create tool extracts notify.user but does not verify Routine.user_id matches ctx.user_id, allowing potential cross-user routine firing if DB constraint is missing https://github.com/nearai/ironclaw/blob/878a67cdb6608527c1bf6ac412180fc1fb2e56bc/src/tools/builtin/routine.rs

23. [HIGH:68] HTTP webhook user_id normalization uses unreachable() fallback - line 1380 assumes normalized_user_id only exists when raw_user_id exists, could panic if normalization logic changes https://github.com/nearai/ironclaw/blob/878a67cdb6608527c1bf6ac412180fc1fb2e56bc/src/channels/http.rs#L1375-L1385

24. [MEDIUM:62] Message tool target resolution falls back to ctx.user_id without owner scope context - ctx.user_id might be guest sender_id rather than owner scope, potentially routing notifications to wrong recipients https://github.com/nearai/ironclaw/blob/878a67cdb6608527c1bf6ac412180fc1fb2e56bc/src/tools/builtin/message.rs

25. [MEDIUM:55] WASM credential resolution fallback hardcoded to 'default' - while ctx.user_id is primary lookup, fallback at line 1170 hardcodes 'default', could mask credential mismatches in multi-owner scenarios

    ironclaw/src/channels/wasm/wrapper.rs

    Lines 1165 to 1175 in 878a67c

    	&self.capabilities,
    	self.secrets_store.as_deref(),
    	&self.owner_scope_id,
    	)
    	.await;
    	let pairing_store = self.pairing_store.clone();
    	let workspace_store = self.workspace_store.clone();
    	// Execute in blocking task with timeout
    	let result = tokio::time::timeout(timeout, async move {
    	tokio::task::spawn_blocking(move || {