OTel: skill invocations are only observable as a metric counter — emit a log event (`codex.skill.injected`) for fleet attribution

diff --git a/codex-rs/core/src/skills.rs b/codex-rs/core/src/skills.rs
index ef610de3..01b1b8a3 100644
--- a/codex-rs/core/src/skills.rs
+++ b/codex-rs/core/src/skills.rs
@@ -73,6 +73,13 @@ pub(crate) async fn emit_explicit_skill_invocations(
                 ("reasoning_effort", reasoning_effort.as_str()),
             ],
         );
+        turn_context.session_telemetry.skill_injected(
+            skill.name.as_str(),
+            status,
+            "explicit",
+            reasoning_effort.as_str(),
+            skill.plugin_id.as_deref(),
+        );
     }
 
     let injected_host_skill_prompts = turn_context
@@ -195,6 +202,13 @@ pub(crate) async fn maybe_emit_implicit_skill_invocation(
             ("reasoning_effort", reasoning_effort.as_str()),
         ],
     );
+    turn_context.session_telemetry.skill_injected(
+        skill_name.as_str(),
+        "ok",
+        "implicit",
+        reasoning_effort.as_str(),
+        invocation.plugin_id.as_deref(),
+    );
     sess.services
         .analytics_events_client
         .track_skill_invocations(
diff --git a/codex-rs/core/tests/suite/otel.rs b/codex-rs/core/tests/suite/otel.rs
index 64b8790f..69cab09b 100644
--- a/codex-rs/core/tests/suite/otel.rs
+++ b/codex-rs/core/tests/suite/otel.rs
@@ -1199,6 +1199,70 @@ fn network_policy_decisions_omit_source_and_destination() {
     }
 }
 
+#[test]
+#[traced_test]
+fn skill_injected_records_log_event() {
+    let telemetry = SessionTelemetry::new(
+        ThreadId::new(),
+        "gpt-5.5",
+        "gpt-5.5",
+        /*account_id*/ None,
+        /*account_email*/ None,
+        Some(TelemetryAuthMode::ApiKey),
+        "Codex_Desktop".to_string(),
+        /*log_user_prompts*/ false,
+        "tty".to_string(),
+        SessionSource::Cli,
+    );
+
+    telemetry.skill_injected(
+        "linear", "ok", "explicit", /*reasoning_effort*/ "default", /*plugin_id*/ None,
+    );
+    telemetry.skill_injected(
+        "my-plugin:docs-review",
+        "ok",
+        "implicit",
+        /*reasoning_effort*/ "high",
+        /*plugin_id*/ Some("my-plugin"),
+    );
+
+    logs_assert(|lines: &[&str]| {
+        let bare = lines
+            .iter()
+            .find(|line| line.contains("codex.skill.injected") && line.contains("skill=linear"))
+            .ok_or_else(|| "missing skill injection event for bare skill".to_string())?;
+        if !bare.contains("status=ok")
+            || !bare.contains("invoke_type=explicit")
+            || !bare.contains("reasoning_effort=default")
+        {
+            return Err("bare skill event missing status/invoke_type/reasoning_effort".to_string());
+        }
+        if bare.contains("plugin_id=") {
+            return Err("bare skill event unexpectedly included a plugin id".to_string());
+        }
+
+        // The log event carries the skill name as-is, including a plugin
+        // namespace prefix.
+        let namespaced = lines
+            .iter()
+            .find(|line| {
+                line.contains("codex.skill.injected")
+                    && line.contains("skill=my-plugin:docs-review")
+            })
+            .ok_or_else(|| "missing skill injection event for plugin skill".to_string())?;
+        if !namespaced.contains("invoke_type=implicit")
+            || !namespaced.contains("reasoning_effort=high")
+        {
+            return Err("plugin skill event missing invoke_type/reasoning_effort".to_string());
+        }
+        if !namespaced.contains("plugin_id=my-plugin") {
+            return Err("plugin skill event missing plugin id".to_string());
+        }
+
+        Ok(())
+    });
+}
+
 #[test]
 #[traced_test]
 fn sandbox_outcome_event_records_outcome() {
diff --git a/codex-rs/otel/src/events/session_telemetry.rs b/codex-rs/otel/src/events/session_telemetry.rs
index 5e8f7ceb..39daa1b1 100644
--- a/codex-rs/otel/src/events/session_telemetry.rs
+++ b/codex-rs/otel/src/events/session_telemetry.rs
@@ -1124,6 +1124,43 @@ impl SessionTelemetry {
         }
     }
 
+    /// Records a skill injection as a log event, alongside the existing
+    /// `codex.skill.injected` metric counter emitted by the caller.
+    ///
+    /// The counter alone cannot support per-conversation or per-device
+    /// attribution: the metrics resource intentionally carries no host
+    /// identity and the counter has no conversation linkage. The log event
+    /// complements it with the log resource and the per-session metadata
+    /// (conversation id, originator) attached by `log_event!`.
+    pub fn skill_injected(
+        &self,
+        skill_name: &str,
+        status: &str,
+        invoke_type: &str,
+        reasoning_effort: &str,
+        plugin_id: Option<&str>,
+    ) {
+        match plugin_id {
+            Some(plugin_id) => log_event!(
+                self,
+                event.name = "codex.skill.injected",
+                skill = %skill_name,
+                status = %status,
+                invoke_type = %invoke_type,
+                reasoning_effort = %reasoning_effort,
+                plugin_id = %plugin_id,
+            ),
+            None => log_event!(
+                self,
+                event.name = "codex.skill.injected",
+                skill = %skill_name,
+                status = %status,
+                invoke_type = %invoke_type,
+                reasoning_effort = %reasoning_effort,
+            ),
+        }
+    }
+
     pub fn sandbox_outcome(
         &self,
         tool_name: &str,