chore(core): drop unused task/state scaffolding

codex-rs/core/src/state/mod.rs

@@ -1,9 +0,0 @@
-mod service;
-mod session;
-mod turn;
-
-pub(crate) use service::SessionServices;
-pub(crate) use session::SessionState;
-pub(crate) use turn::ActiveTurn;
-pub(crate) use turn::RunningTask;
-pub(crate) use turn::TaskKind;

codex-rs/core/src/state/session.rs

@@ -1,80 +0,0 @@
-//! Session-wide mutable state.
-
-use std::collections::HashSet;
-
-use codex_protocol::models::ResponseItem;
-
-use crate::conversation_history::ConversationHistory;
-use crate::protocol::RateLimitSnapshot;
-use crate::protocol::TokenUsage;
-use crate::protocol::TokenUsageInfo;
-
-/// Persistent, session-scoped state previously stored directly on `Session`.
-#[derive(Default)]
-pub(crate) struct SessionState {
-    pub(crate) approved_commands: HashSet<Vec<String>>,
-    pub(crate) history: ConversationHistory,
-    pub(crate) token_info: Option<TokenUsageInfo>,
-    pub(crate) latest_rate_limits: Option<RateLimitSnapshot>,
-}
-
-impl SessionState {
-    /// Create a new session state mirroring previous `State::default()` semantics.
-    pub(crate) fn new() -> Self {
-        Self {
-            history: ConversationHistory::new(),
-            ..Default::default()
-        }
-    }
-
-    // History helpers
-    pub(crate) fn record_items<I>(&mut self, items: I)
-    where
-        I: IntoIterator,
-        I::Item: std::ops::Deref<Target = ResponseItem>,
-    {
-        self.history.record_items(items)
-    }
-
-    pub(crate) fn history_snapshot(&self) -> Vec<ResponseItem> {
-        self.history.contents()
-    }
-
-    pub(crate) fn replace_history(&mut self, items: Vec<ResponseItem>) {
-        self.history.replace(items);
-    }
-
-    // Approved command helpers
-    pub(crate) fn add_approved_command(&mut self, cmd: Vec<String>) {
-        self.approved_commands.insert(cmd);
-    }
-
-    pub(crate) fn approved_commands_ref(&self) -> &HashSet<Vec<String>> {
-        &self.approved_commands
-    }
-
-    // Token/rate limit helpers
-    pub(crate) fn update_token_info_from_usage(
-        &mut self,
-        usage: &TokenUsage,
-        model_context_window: Option<u64>,
-    ) {
-        self.token_info = TokenUsageInfo::new_or_append(
-            &self.token_info,
-            &Some(usage.clone()),
-            model_context_window,
-        );
-    }
-
-    pub(crate) fn set_rate_limits(&mut self, snapshot: RateLimitSnapshot) {
-        self.latest_rate_limits = Some(snapshot);
-    }
-
-    pub(crate) fn token_info_and_rate_limits(
-        &self,
-    ) -> (Option<TokenUsageInfo>, Option<RateLimitSnapshot>) {
-        (self.token_info.clone(), self.latest_rate_limits.clone())
-    }
-
-    // Pending input/approval moved to TurnState.
-}

codex-rs/core/src/state/turn.rs

@@ -1,115 +0,0 @@
-//! Turn-scoped state and active turn metadata scaffolding.
-
-use indexmap::IndexMap;
-use std::collections::HashMap;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-use tokio::task::AbortHandle;
-
-use codex_protocol::models::ResponseInputItem;
-use tokio::sync::oneshot;
-
-use crate::protocol::ReviewDecision;
-use crate::tasks::SessionTask;
-
-/// Metadata about the currently running turn.
-pub(crate) struct ActiveTurn {
-    pub(crate) tasks: IndexMap<String, RunningTask>,
-    pub(crate) turn_state: Arc<Mutex<TurnState>>,
-}
-
-impl Default for ActiveTurn {
-    fn default() -> Self {
-        Self {
-            tasks: IndexMap::new(),
-            turn_state: Arc::new(Mutex::new(TurnState::default())),
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) enum TaskKind {
-    Regular,
-    Review,
-    Compact,
-}
-
-#[derive(Clone)]
-pub(crate) struct RunningTask {
-    pub(crate) handle: AbortHandle,
-    pub(crate) kind: TaskKind,
-    pub(crate) task: Arc<dyn SessionTask>,
-}
-
-impl ActiveTurn {
-    pub(crate) fn add_task(&mut self, sub_id: String, task: RunningTask) {
-        self.tasks.insert(sub_id, task);
-    }
-
-    pub(crate) fn remove_task(&mut self, sub_id: &str) -> bool {
-        self.tasks.swap_remove(sub_id);
-        self.tasks.is_empty()
-    }
-
-    pub(crate) fn drain_tasks(&mut self) -> IndexMap<String, RunningTask> {
-        std::mem::take(&mut self.tasks)
-    }
-}
-
-/// Mutable state for a single turn.
-#[derive(Default)]
-pub(crate) struct TurnState {
-    pending_approvals: HashMap<String, oneshot::Sender<ReviewDecision>>,
-    pending_input: Vec<ResponseInputItem>,
-}
-
-impl TurnState {
-    pub(crate) fn insert_pending_approval(
-        &mut self,
-        key: String,
-        tx: oneshot::Sender<ReviewDecision>,
-    ) -> Option<oneshot::Sender<ReviewDecision>> {
-        self.pending_approvals.insert(key, tx)
-    }
-
-    pub(crate) fn remove_pending_approval(
-        &mut self,
-        key: &str,
-    ) -> Option<oneshot::Sender<ReviewDecision>> {
-        self.pending_approvals.remove(key)
-    }
-
-    pub(crate) fn clear_pending(&mut self) {
-        self.pending_approvals.clear();
-        self.pending_input.clear();
-    }
-
-    pub(crate) fn push_pending_input(&mut self, input: ResponseInputItem) {
-        self.pending_input.push(input);
-    }
-
-    pub(crate) fn take_pending_input(&mut self) -> Vec<ResponseInputItem> {
-        if self.pending_input.is_empty() {
-            Vec::with_capacity(0)
-        } else {
-            let mut ret = Vec::new();
-            std::mem::swap(&mut ret, &mut self.pending_input);
-            ret
-        }
-    }
-}
-
-impl ActiveTurn {
-    /// Clear any pending approvals and input buffered for the current turn.
-    pub(crate) async fn clear_pending(&self) {
-        let mut ts = self.turn_state.lock().await;
-        ts.clear_pending();
-    }
-
-    /// Best-effort, non-blocking variant for synchronous contexts (Drop/interrupt).
-    pub(crate) fn try_clear_pending_sync(&self) {
-        if let Ok(mut ts) = self.turn_state.try_lock() {
-            ts.clear_pending();
-        }
-    }
-}

codex-rs/core/src/tasks/compact.rs

@@ -1,31 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-
-use crate::codex::TurnContext;
-use crate::codex::compact;
-use crate::protocol::InputItem;
-use crate::state::TaskKind;
-
-use super::SessionTask;
-use super::SessionTaskContext;
-
-#[derive(Clone, Copy, Default)]
-pub(crate) struct CompactTask;
-
-#[async_trait]
-impl SessionTask for CompactTask {
-    fn kind(&self) -> TaskKind {
-        TaskKind::Compact
-    }
-
-    async fn run(
-        self: Arc<Self>,
-        session: Arc<SessionTaskContext>,
-        ctx: Arc<TurnContext>,
-        sub_id: String,
-        input: Vec<InputItem>,
-    ) -> Option<String> {
-        compact::run_compact_task(session.clone_session(), ctx, sub_id, input).await
-    }
-}

codex-rs/core/src/tasks/mod.rs

@@ -1,166 +0,0 @@
-mod compact;
-mod regular;
-mod review;
-
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use tracing::trace;
-
-use crate::codex::Session;
-use crate::codex::TurnContext;
-use crate::protocol::Event;
-use crate::protocol::EventMsg;
-use crate::protocol::InputItem;
-use crate::protocol::TaskCompleteEvent;
-use crate::protocol::TurnAbortReason;
-use crate::protocol::TurnAbortedEvent;
-use crate::state::ActiveTurn;
-use crate::state::RunningTask;
-use crate::state::TaskKind;
-
-pub(crate) use compact::CompactTask;
-pub(crate) use regular::RegularTask;
-pub(crate) use review::ReviewTask;
-
-/// Thin wrapper that exposes the parts of [`Session`] task runners need.
-#[derive(Clone)]
-pub(crate) struct SessionTaskContext {
-    session: Arc<Session>,
-}
-
-impl SessionTaskContext {
-    pub(crate) fn new(session: Arc<Session>) -> Self {
-        Self { session }
-    }
-
-    pub(crate) fn clone_session(&self) -> Arc<Session> {
-        Arc::clone(&self.session)
-    }
-}
-
-#[async_trait]
-pub(crate) trait SessionTask: Send + Sync + 'static {
-    fn kind(&self) -> TaskKind;
-
-    async fn run(
-        self: Arc<Self>,
-        session: Arc<SessionTaskContext>,
-        ctx: Arc<TurnContext>,
-        sub_id: String,
-        input: Vec<InputItem>,
-    ) -> Option<String>;
-
-    async fn abort(&self, session: Arc<SessionTaskContext>, sub_id: &str) {
-        let _ = (session, sub_id);
-    }
-}
-
-impl Session {
-    pub async fn spawn_task<T: SessionTask>(
-        self: &Arc<Self>,
-        turn_context: Arc<TurnContext>,
-        sub_id: String,
-        input: Vec<InputItem>,
-        task: T,
-    ) {
-        self.abort_all_tasks(TurnAbortReason::Replaced).await;
-
-        let task: Arc<dyn SessionTask> = Arc::new(task);
-        let task_kind = task.kind();
-
-        let handle = {
-            let session_ctx = Arc::new(SessionTaskContext::new(Arc::clone(self)));
-            let ctx = Arc::clone(&turn_context);
-            let task_for_run = Arc::clone(&task);
-            let sub_clone = sub_id.clone();
-            tokio::spawn(async move {
-                let last_agent_message = task_for_run
-                    .run(Arc::clone(&session_ctx), ctx, sub_clone.clone(), input)
-                    .await;
-                // Emit completion uniformly from spawn site so all tasks share the same lifecycle.
-                let sess = session_ctx.clone_session();
-                sess.on_task_finished(sub_clone, last_agent_message).await;
-            })
-            .abort_handle()
-        };
-
-        let running_task = RunningTask {
-            handle,
-            kind: task_kind,
-            task,
-        };
-        self.register_new_active_task(sub_id, running_task).await;
-    }
-
-    pub async fn abort_all_tasks(self: &Arc<Self>, reason: TurnAbortReason) {
-        for (sub_id, task) in self.take_all_running_tasks().await {
-            self.handle_task_abort(sub_id, task, reason.clone()).await;
-        }
-    }
-
-    pub async fn on_task_finished(
-        self: &Arc<Self>,
-        sub_id: String,
-        last_agent_message: Option<String>,
-    ) {
-        let mut active = self.active_turn.lock().await;
-        if let Some(at) = active.as_mut()
-            && at.remove_task(&sub_id)
-        {
-            *active = None;
-        }
-        drop(active);
-        let event = Event {
-            id: sub_id,
-            msg: EventMsg::TaskComplete(TaskCompleteEvent { last_agent_message }),
-        };
-        self.send_event(event).await;
-    }
-
-    async fn register_new_active_task(&self, sub_id: String, task: RunningTask) {
-        let mut active = self.active_turn.lock().await;
-        let mut turn = ActiveTurn::default();
-        turn.add_task(sub_id, task);
-        *active = Some(turn);
-    }
-
-    async fn take_all_running_tasks(&self) -> Vec<(String, RunningTask)> {
-        let mut active = self.active_turn.lock().await;
-        match active.take() {
-            Some(mut at) => {
-                at.clear_pending().await;
-                let tasks = at.drain_tasks();
-                tasks.into_iter().collect()
-            }
-            None => Vec::new(),
-        }
-    }
-
-    async fn handle_task_abort(
-        self: &Arc<Self>,
-        sub_id: String,
-        task: RunningTask,
-        reason: TurnAbortReason,
-    ) {
-        if task.handle.is_finished() {
-            return;
-        }
-
-        trace!(task_kind = ?task.kind, sub_id, "aborting running task");
-        let session_task = task.task;
-        let handle = task.handle;
-        handle.abort();
-        let session_ctx = Arc::new(SessionTaskContext::new(Arc::clone(self)));
-        session_task.abort(session_ctx, &sub_id).await;
-
-        let event = Event {
-            id: sub_id.clone(),
-            msg: EventMsg::TurnAborted(TurnAbortedEvent { reason }),
-        };
-        self.send_event(event).await;
-    }
-}
-
-#[cfg(test)]
-mod tests {}

codex-rs/core/src/tasks/regular.rs

@@ -1,32 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-
-use crate::codex::TurnContext;
-use crate::codex::run_task;
-use crate::protocol::InputItem;
-use crate::state::TaskKind;
-
-use super::SessionTask;
-use super::SessionTaskContext;
-
-#[derive(Clone, Copy, Default)]
-pub(crate) struct RegularTask;
-
-#[async_trait]
-impl SessionTask for RegularTask {
-    fn kind(&self) -> TaskKind {
-        TaskKind::Regular
-    }
-
-    async fn run(
-        self: Arc<Self>,
-        session: Arc<SessionTaskContext>,
-        ctx: Arc<TurnContext>,
-        sub_id: String,
-        input: Vec<InputItem>,
-    ) -> Option<String> {
-        let sess = session.clone_session();
-        run_task(sess, ctx, sub_id, input).await
-    }
-}

codex-rs/core/src/tasks/review.rs

@@ -1,37 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-
-use crate::codex::TurnContext;
-use crate::codex::exit_review_mode;
-use crate::codex::run_task;
-use crate::protocol::InputItem;
-use crate::state::TaskKind;
-
-use super::SessionTask;
-use super::SessionTaskContext;
-
-#[derive(Clone, Copy, Default)]
-pub(crate) struct ReviewTask;
-
-#[async_trait]
-impl SessionTask for ReviewTask {
-    fn kind(&self) -> TaskKind {
-        TaskKind::Review
-    }
-
-    async fn run(
-        self: Arc<Self>,
-        session: Arc<SessionTaskContext>,
-        ctx: Arc<TurnContext>,
-        sub_id: String,
-        input: Vec<InputItem>,
-    ) -> Option<String> {
-        let sess = session.clone_session();
-        run_task(sess, ctx, sub_id, input).await
-    }
-
-    async fn abort(&self, session: Arc<SessionTaskContext>, sub_id: &str) {
-        exit_review_mode(session.clone_session(), sub_id.to_string(), None).await;
-    }
-}