Organize context fragments

codex-rs/Cargo.toml

@@ -31,7 +31,6 @@ members = [
     "core-plugins",
     "core-skills",
     "hooks",
-    "instructions",
     "secrets",
     "exec",
     "exec-server",
@@ -143,7 +142,6 @@ codex-install-context = { path = "install-context" }
 codex-file-search = { path = "file-search" }
 codex-git-utils = { path = "git-utils" }
 codex-hooks = { path = "hooks" }
-codex-instructions = { path = "instructions" }
 codex-keyring-store = { path = "keyring-store" }
 codex-linux-sandbox = { path = "linux-sandbox" }
 codex-lmstudio = { path = "lmstudio" }

codex-rs/core-skills/Cargo.toml

@@ -18,7 +18,6 @@ codex-analytics = { workspace = true }
 codex-app-server-protocol = { workspace = true }
 codex-config = { workspace = true }
 codex-exec-server = { workspace = true }
-codex-instructions = { workspace = true }
 codex-login = { workspace = true }
 codex-otel = { workspace = true }
 codex-protocol = { workspace = true }

codex-rs/core-skills/src/injection.rs

@@ -10,19 +10,24 @@ use codex_analytics::InvocationType;
 use codex_analytics::SkillInvocation;
 use codex_analytics::TrackEventsContext;
 use codex_exec_server::LOCAL_FS;
-use codex_instructions::SkillInstructions;
 use codex_otel::SessionTelemetry;
-use codex_protocol::models::ResponseItem;
 use codex_protocol::user_input::UserInput;
 use codex_utils_absolute_path::AbsolutePathBuf;
 use codex_utils_plugins::mention_syntax::TOOL_MENTION_SIGIL;
 
 #[derive(Debug, Default)]
 pub struct SkillInjections {
-    pub items: Vec<ResponseItem>,
+    pub items: Vec<SkillInjection>,
     pub warnings: Vec<String>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SkillInjection {
+    pub name: String,
+    pub path: String,
+    pub contents: String,
+}
+
 pub async fn build_skill_injections(
     mentioned_skills: &[SkillMetadata],
     loaded_skills: Option<&SkillLoadOutcome>,
@@ -56,11 +61,11 @@ pub async fn build_skill_injections(
                     skill_path: skill.path_to_skills_md.to_path_buf(),
                     invocation_type: InvocationType::Explicit,
                 });
-                result.items.push(ResponseItem::from(SkillInstructions {
+                result.items.push(SkillInjection {
                     name: skill.name.clone(),
                     path: skill.path_to_skills_md.to_string_lossy().into_owned(),
                     contents,
-                }));
+                });
             }
             Err(err) => {
                 emit_skill_injected_metric(otel, skill, "error");

codex-rs/core/Cargo.toml

@@ -48,7 +48,6 @@ codex-shell-command = { workspace = true }
 codex-execpolicy = { workspace = true }
 codex-git-utils = { workspace = true }
 codex-hooks = { workspace = true }
-codex-instructions = { workspace = true }
 codex-network-proxy = { workspace = true }
 codex-otel = { workspace = true }
 codex-plugin = { workspace = true }

codex-rs/core/src/agent/control_tests.rs

@@ -5,7 +5,8 @@ use crate::agent::agent_status_from_event;
 use crate::config::AgentRoleConfig;
 use crate::config::Config;
 use crate::config::ConfigBuilder;
-use crate::contextual_user_message::SUBAGENT_NOTIFICATION_OPEN_TAG;
+use crate::context::ContextualUserFragment;
+use crate::context::SubagentNotification;
 use assert_matches::assert_matches;
 use codex_features::Feature;
 use codex_login::CodexAuth;
@@ -127,7 +128,7 @@ fn has_subagent_notification(history_items: &[ResponseItem]) -> bool {
         }
         content.iter().any(|content_item| match content_item {
             ContentItem::InputText { text } | ContentItem::OutputText { text } => {
-                text.contains(SUBAGENT_NOTIFICATION_OPEN_TAG)
+                SubagentNotification::matches_text(text)
             }
             ContentItem::InputImage { .. } => false,
         })

codex-rs/core/src/arc_monitor_tests.rs

@@ -1,5 +1,6 @@
 use std::env;
 use std::ffi::OsStr;
+use std::path::PathBuf;
 use std::sync::Arc;
 
 use pretty_assertions::assert_eq;
@@ -16,6 +17,7 @@ use wiremock::matchers::path;
 use super::*;
 use crate::agent_identity::AgentIdentityManager;
 use crate::agent_identity::RegisteredAgentTask;
+use crate::context::ContextualUserFragment;
 use crate::session::tests::make_session_and_context;
 use chrono::Utc;
 use codex_login::AuthCredentialsStoreMode;
@@ -143,11 +145,16 @@ async fn build_arc_monitor_request_includes_relevant_history_and_null_policies()
         .await;
     session
         .record_into_history(
-            &[
-                crate::contextual_user_message::ENVIRONMENT_CONTEXT_FRAGMENT.into_message(
-                    "<environment_context>\n<cwd>/tmp</cwd>\n</environment_context>".to_string(),
+            &[ContextualUserFragment::into(
+                crate::context::EnvironmentContext::new(
+                    Some(PathBuf::from("/tmp")),
+                    "zsh".to_string(),
+                    /*current_date*/ None,
+                    /*timezone*/ None,
+                    /*network*/ None,
+                    /*subagents*/ None,
                 ),
-            ],
+            )],
             &turn_context,
         )
         .await;

codex-rs/core/src/contextual_user_message.rs → codex-rs/core/src/context/contextual_user_message.rs

@@ -1,50 +1,47 @@
-use codex_instructions::AGENTS_MD_FRAGMENT;
-use codex_instructions::ContextualUserFragmentDefinition;
-use codex_instructions::SKILL_FRAGMENT;
 use codex_protocol::items::HookPromptItem;
 use codex_protocol::items::parse_hook_prompt_fragment;
 use codex_protocol::models::ContentItem;
-use codex_protocol::protocol::ENVIRONMENT_CONTEXT_CLOSE_TAG;
-use codex_protocol::protocol::ENVIRONMENT_CONTEXT_OPEN_TAG;
 
-pub(crate) const USER_SHELL_COMMAND_OPEN_TAG: &str = "<user_shell_command>";
-pub(crate) const USER_SHELL_COMMAND_CLOSE_TAG: &str = "</user_shell_command>";
-pub(crate) const TURN_ABORTED_OPEN_TAG: &str = "<turn_aborted>";
-pub(crate) const TURN_ABORTED_CLOSE_TAG: &str = "</turn_aborted>";
-pub(crate) const SUBAGENT_NOTIFICATION_OPEN_TAG: &str = "<subagent_notification>";
-pub(crate) const SUBAGENT_NOTIFICATION_CLOSE_TAG: &str = "</subagent_notification>";
+use super::EnvironmentContext;
+use super::FragmentRegistration;
+use super::FragmentRegistrationProxy;
+use super::SkillInstructions;
+use super::SubagentNotification;
+use super::TurnAborted;
+use super::UserInstructions;
+use super::UserShellCommand;
 
-pub(crate) const ENVIRONMENT_CONTEXT_FRAGMENT: ContextualUserFragmentDefinition =
-    ContextualUserFragmentDefinition::new(
-        ENVIRONMENT_CONTEXT_OPEN_TAG,
-        ENVIRONMENT_CONTEXT_CLOSE_TAG,
-    );
-pub(crate) const USER_SHELL_COMMAND_FRAGMENT: ContextualUserFragmentDefinition =
-    ContextualUserFragmentDefinition::new(
-        USER_SHELL_COMMAND_OPEN_TAG,
-        USER_SHELL_COMMAND_CLOSE_TAG,
-    );
-pub(crate) const TURN_ABORTED_FRAGMENT: ContextualUserFragmentDefinition =
-    ContextualUserFragmentDefinition::new(TURN_ABORTED_OPEN_TAG, TURN_ABORTED_CLOSE_TAG);
-pub(crate) const SUBAGENT_NOTIFICATION_FRAGMENT: ContextualUserFragmentDefinition =
-    ContextualUserFragmentDefinition::new(
-        SUBAGENT_NOTIFICATION_OPEN_TAG,
-        SUBAGENT_NOTIFICATION_CLOSE_TAG,
-    );
+static USER_INSTRUCTIONS_REGISTRATION: FragmentRegistrationProxy<UserInstructions> =
+    FragmentRegistrationProxy::new();
+static ENVIRONMENT_CONTEXT_REGISTRATION: FragmentRegistrationProxy<EnvironmentContext> =
+    FragmentRegistrationProxy::new();
+static SKILL_INSTRUCTIONS_REGISTRATION: FragmentRegistrationProxy<SkillInstructions> =
+    FragmentRegistrationProxy::new();
+static USER_SHELL_COMMAND_REGISTRATION: FragmentRegistrationProxy<UserShellCommand> =
+    FragmentRegistrationProxy::new();
+static TURN_ABORTED_REGISTRATION: FragmentRegistrationProxy<TurnAborted> =
+    FragmentRegistrationProxy::new();
+static SUBAGENT_NOTIFICATION_REGISTRATION: FragmentRegistrationProxy<SubagentNotification> =
+    FragmentRegistrationProxy::new();
 
-const CONTEXTUAL_USER_FRAGMENTS: &[ContextualUserFragmentDefinition] = &[
-    AGENTS_MD_FRAGMENT,
-    ENVIRONMENT_CONTEXT_FRAGMENT,
-    SKILL_FRAGMENT,
-    USER_SHELL_COMMAND_FRAGMENT,
-    TURN_ABORTED_FRAGMENT,
-    SUBAGENT_NOTIFICATION_FRAGMENT,
+static CONTEXTUAL_USER_FRAGMENTS: &[&dyn FragmentRegistration] = &[
+    &USER_INSTRUCTIONS_REGISTRATION,
+    &ENVIRONMENT_CONTEXT_REGISTRATION,
+    &SKILL_INSTRUCTIONS_REGISTRATION,
+    &USER_SHELL_COMMAND_REGISTRATION,
+    &TURN_ABORTED_REGISTRATION,
+    &SUBAGENT_NOTIFICATION_REGISTRATION,
+];
+
+static MEMORY_EXCLUDED_CONTEXTUAL_USER_FRAGMENTS: &[&dyn FragmentRegistration] = &[
+    &USER_INSTRUCTIONS_REGISTRATION,
+    &SKILL_INSTRUCTIONS_REGISTRATION,
 ];
 
 fn is_standard_contextual_user_text(text: &str) -> bool {
     CONTEXTUAL_USER_FRAGMENTS
         .iter()
-        .any(|definition| definition.matches_text(text))
+        .any(|fragment| fragment.matches_text(text))
 }
 
 /// Returns whether a contextual user fragment should be omitted from memory
@@ -59,7 +56,9 @@ pub(crate) fn is_memory_excluded_contextual_user_fragment(content_item: &Content
     let ContentItem::InputText { text } = content_item else {
         return false;
     };
-    AGENTS_MD_FRAGMENT.matches_text(text) || SKILL_FRAGMENT.matches_text(text)
+    MEMORY_EXCLUDED_CONTEXTUAL_USER_FRAGMENTS
+        .iter()
+        .any(|fragment| fragment.matches_text(text))
 }
 
 pub(crate) fn is_contextual_user_fragment(content_item: &ContentItem) -> bool {

codex-rs/core/src/contextual_user_message_tests.rs → codex-rs/core/src/context/contextual_user_message_tests.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::context::ContextualUserFragment;
 use codex_protocol::items::HookPromptFragment;
 use codex_protocol::items::build_hook_prompt_message;
 use codex_protocol::models::ResponseItem;
@@ -20,10 +21,9 @@ fn detects_agents_instructions_fragment() {
 
 #[test]
 fn detects_subagent_notification_fragment_case_insensitively() {
-    assert!(
-        SUBAGENT_NOTIFICATION_FRAGMENT
-            .matches_text("<SUBAGENT_NOTIFICATION>{}</subagent_notification>")
-    );
+    assert!(SubagentNotification::matches_text(
+        "<SUBAGENT_NOTIFICATION>{}</subagent_notification>"
+    ));
 }
 
 #[test]