Lightweight coding agent that runs in your terminal
Rust
Account subagent token usage toward root goals (#41183)
Eric Traut4761851ff35c
diff --git a/codex-rs/ext/goal/src/accounting.rs b/codex-rs/ext/goal/src/accounting.rsindex ea942ea158..4012a9587b 100644--- a/codex-rs/ext/goal/src/accounting.rs+++ b/codex-rs/ext/goal/src/accounting.rs@@ -4,6 +4,8 @@ use codex_state::ThreadGoalStatus;use std::collections::HashMap;use std::sync::Mutex;use std::sync::PoisonError;+use std::sync::atomic::AtomicI64;+use std::sync::atomic::Ordering;use std::time::Duration;use std::time::Instant;use tokio::sync::Semaphore;@@ -13,6 +15,7 @@ use tokio::sync::SemaphorePermit;pub(crate) struct GoalAccountingState {inner: Mutex<GoalAccountingInner>,progress_accounting_lock: Semaphore,+ descendant_token_usage: AtomicI64,}#[derive(Debug)]@@ -21,6 +24,7 @@ struct GoalAccountingInner {turns: HashMap<String, GoalTurnAccounting>,wall_clock: GoalWallClockAccounting,budget_limit_reported_goal_id: Option<String>,+ last_accounted_descendant_token_usage: i64,}#[derive(Debug)]@@ -40,6 +44,7 @@ struct GoalWallClockAccounting {#[derive(Debug, Clone)]pub(crate) struct GoalProgressSnapshot {pub(crate) current_token_usage: TokenUsage,+ current_descendant_token_usage: i64,pub(crate) expected_goal_id: String,pub(crate) time_delta_seconds: i64,pub(crate) token_delta: i64,@@ -47,8 +52,10 @@ pub(crate) struct GoalProgressSnapshot {#[derive(Debug, Clone)]pub(crate) struct IdleGoalProgressSnapshot {+ current_descendant_token_usage: i64,pub(crate) expected_goal_id: String,pub(crate) time_delta_seconds: i64,+ pub(crate) token_delta: i64,}#[derive(Debug, Clone, Copy, PartialEq, Eq)]@@ -131,6 +138,14 @@ impl GoalAccountingState {})}+ pub(crate) fn record_descendant_token_usage(&self, usage: &TokenUsage) {+ let delta = goal_token_delta_for_usage(usage);+ if delta > 0 {+ self.descendant_token_usage+ .fetch_add(delta, Ordering::Relaxed);+ }+ }+pub(crate) fn mark_turn_goal_active(&self, turn_id: &str, goal_id: impl Into<String>) {let mut inner = self.inner();let goal_id = goal_id.into();@@ -140,6 +155,10 @@ impl GoalAccountingState {if let Some(turn) = inner.turns.get_mut(turn_id) {turn.active_goal_id = Some(goal_id.clone());if inner.current_turn_id.as_deref() == Some(turn_id) {+ if inner.wall_clock.active_goal_id.as_deref() != Some(goal_id.as_str()) {+ inner.last_accounted_descendant_token_usage =+ self.descendant_token_usage.load(Ordering::Relaxed);+ }inner.wall_clock.mark_active_goal(goal_id);}}@@ -155,9 +174,14 @@ impl GoalAccountingState {if inner.budget_limit_reported_goal_id.as_deref() != Some(goal_id.as_str()) {inner.budget_limit_reported_goal_id = None;}+ let goal_changed = inner.wall_clock.active_goal_id.as_deref() != Some(goal_id.as_str());let turn = inner.turns.get_mut(turn_id.as_str())?;turn.active_goal_id = Some(goal_id.clone());- turn.reset_baseline_to_current();+ if goal_changed {+ turn.reset_baseline_to_current();+ inner.last_accounted_descendant_token_usage =+ self.descendant_token_usage.load(Ordering::Relaxed);+ }inner.wall_clock.mark_active_goal(goal_id);Some(turn_id)}@@ -168,6 +192,10 @@ impl GoalAccountingState {if inner.budget_limit_reported_goal_id.as_deref() != Some(goal_id.as_str()) {inner.budget_limit_reported_goal_id = None;}+ if inner.wall_clock.active_goal_id.as_deref() != Some(goal_id.as_str()) {+ inner.last_accounted_descendant_token_usage =+ self.descendant_token_usage.load(Ordering::Relaxed);+ }inner.wall_clock.mark_active_goal(goal_id);}@@ -200,7 +228,12 @@ impl GoalAccountingState {return None;}let expected_goal_id = turn.active_goal_id()?;- let token_delta = turn.token_delta_since_last_accounting();+ let current_descendant_token_usage = self.descendant_token_usage.load(Ordering::Relaxed);+ let descendant_token_delta = current_descendant_token_usage+ .saturating_sub(inner.last_accounted_descendant_token_usage);+ let token_delta = turn+ .token_delta_since_last_accounting()+ .saturating_add(descendant_token_delta);let time_delta_seconds =if inner.wall_clock.active_goal_id.as_deref() == Some(expected_goal_id.as_str()) {inner.wall_clock.time_delta_since_last_accounting()@@ -212,6 +245,7 @@ impl GoalAccountingState {}Some(GoalProgressSnapshot {current_token_usage: turn.current_token_usage.clone(),+ current_descendant_token_usage,expected_goal_id,time_delta_seconds,token_delta,@@ -222,12 +256,17 @@ impl GoalAccountingState {let inner = self.inner();let expected_goal_id = inner.wall_clock.active_goal_id.clone()?;let time_delta_seconds = inner.wall_clock.time_delta_since_last_accounting();- if time_delta_seconds == 0 {+ let current_descendant_token_usage = self.descendant_token_usage.load(Ordering::Relaxed);+ let token_delta = current_descendant_token_usage+ .saturating_sub(inner.last_accounted_descendant_token_usage);+ if time_delta_seconds == 0 && token_delta <= 0 {return None;}Some(IdleGoalProgressSnapshot {+ current_descendant_token_usage,expected_goal_id,time_delta_seconds,+ token_delta,})}@@ -246,6 +285,7 @@ impl GoalAccountingState {turn.active_goal_id = None;}}+ inner.last_accounted_descendant_token_usage = snapshot.current_descendant_token_usage;inner.wall_clock.mark_accounted(snapshot.time_delta_seconds);if clear_active_goal {inner.wall_clock.clear_active_goal();@@ -271,6 +311,7 @@ impl GoalAccountingState {) {let clear_active_goal = should_clear_active_goal(status, budget_limited_goal_disposition);let mut inner = self.inner();+ inner.last_accounted_descendant_token_usage = snapshot.current_descendant_token_usage;inner.wall_clock.mark_accounted(snapshot.time_delta_seconds);if clear_active_goal {inner.wall_clock.clear_active_goal();@@ -306,6 +347,7 @@ impl Default for GoalAccountingState {Self {inner: Mutex::new(GoalAccountingInner::default()),progress_accounting_lock: Semaphore::new(/*permits*/ 1),+ descendant_token_usage: AtomicI64::new(0),}}}@@ -343,6 +385,7 @@ impl Default for GoalAccountingInner {turns: HashMap::new(),wall_clock: GoalWallClockAccounting::new(),budget_limit_reported_goal_id: None,+ last_accounted_descendant_token_usage: 0,}}}diff --git a/codex-rs/ext/goal/src/api.rs b/codex-rs/ext/goal/src/api.rsindex 149c95d0a1..94397d55b4 100644--- a/codex-rs/ext/goal/src/api.rs+++ b/codex-rs/ext/goal/src/api.rs@@ -345,7 +345,7 @@ impl GoalService {}}- fn runtime_for_thread(&self, thread_id: ThreadId) -> Option<Arc<GoalRuntimeHandle>> {+ pub(crate) fn runtime_for_thread(&self, thread_id: ThreadId) -> Option<Arc<GoalRuntimeHandle>> {let key = thread_id.to_string();let mut runtimes = self.runtimes();let runtime = runtimes.get(&key).and_then(Weak::upgrade);diff --git a/codex-rs/ext/goal/src/extension.rs b/codex-rs/ext/goal/src/extension.rsindex 24d515c613..349652da4f 100644--- a/codex-rs/ext/goal/src/extension.rs+++ b/codex-rs/ext/goal/src/extension.rs@@ -110,6 +110,30 @@ wherelet Ok(thread_id) = ThreadId::from_string(input.thread_store.level_id()) else {return;};+ let root_accounting_state = input+ .session_source+ .parent_thread_id()+ .or_else(|| {+ ThreadId::from_string(input.session_store.level_id())+ .ok()+ .filter(|_| input.session_source.is_non_root_agent())+ })+ .and_then(|parent_thread_id| {+ self.goal_service+ .runtime_for_thread(parent_thread_id)+ .or_else(|| {+ ThreadId::from_string(input.session_store.level_id())+ .ok()+ .and_then(|root_thread_id| {+ self.goal_service.runtime_for_thread(root_thread_id)+ })+ })+ })+ .map(|parent| {+ parent+ .root_accounting_state()+ .unwrap_or_else(|| parent.accounting_state())+ });let runtime = input.thread_store.get_or_init::<GoalRuntimeHandle>(|| {GoalRuntimeHandle::new(thread_id,@@ -122,6 +146,7 @@ whereanalytics: self.analytics.clone(),enabled,tools_available_for_thread,+ root_accounting_state,},)});@@ -346,12 +371,12 @@ wherereturn;}- let Some(_recorded) = runtime+ if let Some(root_accounting_state) = runtime.root_accounting_state() {+ root_accounting_state.record_descendant_token_usage(&token_usage.last_token_usage);+ }+ let _ = runtime.accounting_state()- .record_token_usage(turn_store.level_id(), &token_usage.total_token_usage)- else {- return;- };+ .record_token_usage(turn_store.level_id(), &token_usage.total_token_usage);})}}diff --git a/codex-rs/ext/goal/src/runtime.rs b/codex-rs/ext/goal/src/runtime.rsindex d0579090fd..d9f0f0df24 100644--- a/codex-rs/ext/goal/src/runtime.rs+++ b/codex-rs/ext/goal/src/runtime.rs@@ -33,6 +33,7 @@ pub(crate) struct GoalRuntimeConfig {pub(crate) analytics: GoalAnalytics,pub(crate) enabled: bool,pub(crate) tools_available_for_thread: bool,+ pub(crate) root_accounting_state: Option<Arc<GoalAccountingState>>,}pub(crate) enum ActiveGoalStopReason {@@ -48,6 +49,7 @@ struct GoalRuntimeInner {metrics: GoalMetrics,thread_manager: Weak<ThreadManager>,accounting_state: Arc<GoalAccountingState>,+ root_accounting_state: Option<Arc<GoalAccountingState>>,enabled: AtomicBool,tools_available_for_thread: bool,goal_state_lock: Semaphore,@@ -100,6 +102,7 @@ impl GoalRuntimeHandle {metrics,thread_manager,accounting_state,+ root_accounting_state: config.root_accounting_state,enabled: AtomicBool::new(config.enabled),tools_available_for_thread: config.tools_available_for_thread,goal_state_lock: Semaphore::new(/*permits*/ 1),@@ -127,6 +130,10 @@ impl GoalRuntimeHandle {Arc::clone(&self.inner.accounting_state)}+ pub(crate) fn root_accounting_state(&self) -> Option<Arc<GoalAccountingState>> {+ self.inner.root_accounting_state.clone()+ }+pub(crate) async fn goal_state_permit(&self) -> Result<SemaphorePermit<'_>, String> {self.inner.goal_state_lock@@ -546,7 +553,7 @@ impl GoalRuntimeHandle {.account_thread_goal_usage(self.thread_id(),snapshot.time_delta_seconds,- /*token_delta*/ 0,+ snapshot.token_delta,mode,Some(snapshot.expected_goal_id.as_str()),)diff --git a/codex-rs/ext/goal/tests/accounting.rs b/codex-rs/ext/goal/tests/accounting.rsindex d5b601c997..9bd1186f08 100644--- a/codex-rs/ext/goal/tests/accounting.rs+++ b/codex-rs/ext/goal/tests/accounting.rs@@ -3,9 +3,11 @@#[path = "../src/accounting.rs"]mod accounting;+use accounting::BudgetLimitedGoalDisposition;use accounting::GoalAccountingState;use codex_protocol::config_types::ModeKind;use codex_protocol::protocol::TokenUsage;+use codex_state::ThreadGoalStatus;use pretty_assertions::assert_eq;#[test]@@ -51,6 +53,46 @@ fn goal_accounting_ignores_plan_mode_turns() {assert_eq!(None, recorded);}+#[test]+fn goal_accounting_preserves_concurrent_descendant_usage_across_checkpoints() {+ let state = GoalAccountingState::default();+ state.start_turn("turn-1", ModeKind::Default, &TokenUsage::default());+ state.mark_current_turn_goal_active("goal-1");+ let first_usage = token_usage(+ /*input_tokens*/ 20, /*cached_input_tokens*/ 5, /*output_tokens*/ 8,+ /*reasoning_output_tokens*/ 0, /*total_tokens*/ 28,+ );+ let second_usage = token_usage(+ /*input_tokens*/ 8, /*cached_input_tokens*/ 2, /*output_tokens*/ 4,+ /*reasoning_output_tokens*/ 0, /*total_tokens*/ 12,+ );+ std::thread::scope(|scope| {+ scope.spawn(|| state.record_descendant_token_usage(&first_usage));+ scope.spawn(|| state.record_descendant_token_usage(&second_usage));+ });++ let first = state+ .progress_snapshot("turn-1")+ .expect("descendant usage should create a progress snapshot");+ assert_eq!(33, first.token_delta);++ state.record_descendant_token_usage(&token_usage(+ /*input_tokens*/ 6, /*cached_input_tokens*/ 1, /*output_tokens*/ 3,+ /*reasoning_output_tokens*/ 0, /*total_tokens*/ 9,+ ));+ state.mark_progress_accounted_for_status(+ "turn-1",+ &first,+ ThreadGoalStatus::Active,+ BudgetLimitedGoalDisposition::KeepActive,+ );++ let second = state+ .progress_snapshot("turn-1")+ .expect("usage received during accounting should remain pending");+ assert_eq!(8, second.token_delta);+}+fn token_usage(input_tokens: i64,cached_input_tokens: i64,diff --git a/codex-rs/ext/goal/tests/goal_extension_backend.rs b/codex-rs/ext/goal/tests/goal_extension_backend.rsindex 72832764e8..e029f121fe 100644--- a/codex-rs/ext/goal/tests/goal_extension_backend.rs+++ b/codex-rs/ext/goal/tests/goal_extension_backend.rs@@ -409,6 +409,186 @@ async fn parallel_tool_finish_accounts_active_goal_progress_once() -> anyhow::ReOk(())}+#[tokio::test]+async fn spawned_descendant_usage_exhausts_root_goal_budget_once() -> anyhow::Result<()> {+ let runtime = test_runtime().await?;+ let thread_id = test_thread_id()?;+ seed_thread_metadata(runtime.as_ref(), thread_id).await?;+ let harness = GoalExtensionHarness::new(runtime.clone(), thread_id).await?;+ harness.start_turn("turn-1", &TokenUsage::default()).await;++ let child = harness.spawn_child(ThreadId::new()).await?;+ child.start_turn("child-turn", &TokenUsage::default()).await;+ let grandchild = child+ .spawn_child_with_source(ThreadId::new(), SubAgentSource::Review)+ .await?;+ grandchild+ .start_turn("grandchild-turn", &TokenUsage::default())+ .await;+ let tools = harness.tools();+ tool_by_name(&tools, "create_goal")+ .handle(tool_call(+ "create_goal",+ "call-create-goal",+ json!({ "objective": "account for the entire agent tree", "token_budget": 62 }),+ ))+ .await?;++ harness+ .record_token_usage(+ "turn-1",+ &token_usage(+ /*input_tokens*/ 12, /*cached_input_tokens*/ 2, /*output_tokens*/ 4,+ /*reasoning_output_tokens*/ 0, /*total_tokens*/ 16,+ ),+ )+ .await;+ let first_child_usage = input_token_usage(/*input_tokens*/ 23);+ child+ .record_token_usage_with_last("child-turn", &first_child_usage, &first_child_usage)+ .await;+ child+ .record_token_usage_with_last(+ "child-turn",+ &input_token_usage(/*input_tokens*/ 36),+ &input_token_usage(/*input_tokens*/ 13),+ )+ .await;+ let grandchild_usage = input_token_usage(/*input_tokens*/ 12);+ grandchild+ .record_token_usage_with_last("grandchild-turn", &grandchild_usage, &grandchild_usage)+ .await;+ harness+ .notify_tool_finish("turn-1", "call-shell", "shell")+ .await;++ let goal = runtime+ .thread_goals()+ .get_thread_goal(thread_id)+ .await?+ .ok_or_else(|| anyhow::anyhow!("goal should exist"))?;+ assert_eq!(62, goal.tokens_used);+ assert_eq!(codex_state::ThreadGoalStatus::BudgetLimited, goal.status);+ Ok(())+}++#[tokio::test]+async fn grandchild_usage_rolls_up_after_parent_runtime_unloads() -> anyhow::Result<()> {+ let runtime = test_runtime().await?;+ let thread_id = test_thread_id()?;+ seed_thread_metadata(runtime.as_ref(), thread_id).await?;+ let harness = GoalExtensionHarness::new(runtime.clone(), thread_id).await?;+ harness.start_turn("turn-1", &TokenUsage::default()).await;++ let tools = harness.tools();+ tool_by_name(&tools, "create_goal")+ .handle(tool_call(+ "create_goal",+ "call-create-goal",+ json!({ "objective": "account for evicted agent trees" }),+ ))+ .await?;++ let child = harness.spawn_child(ThreadId::new()).await?;+ child.stop_thread().await;+ let grandchild = child.spawn_child(ThreadId::new()).await?;+ grandchild+ .start_turn("grandchild-turn", &TokenUsage::default())+ .await;+ let usage = input_token_usage(/*input_tokens*/ 23);+ grandchild+ .record_token_usage_with_last("grandchild-turn", &usage, &usage)+ .await;+ harness+ .notify_tool_finish("turn-1", "call-shell", "shell")+ .await;++ let goal = runtime+ .thread_goals()+ .get_thread_goal(thread_id)+ .await?+ .ok_or_else(|| anyhow::anyhow!("goal should exist"))?;+ assert_eq!(23, goal.tokens_used);+ Ok(())+}++#[tokio::test]+async fn subagent_usage_resets_when_root_goal_is_replaced() -> anyhow::Result<()> {+ let runtime = test_runtime().await?;+ let thread_id = test_thread_id()?;+ seed_thread_metadata(runtime.as_ref(), thread_id).await?;+ let harness = GoalExtensionHarness::new(runtime.clone(), thread_id).await?;+ harness.start_turn("turn-1", &TokenUsage::default()).await;+ let child = harness.spawn_child(ThreadId::new()).await?;+ child.start_turn("child-turn", &TokenUsage::default()).await;++ let previous_usage = input_token_usage(/*input_tokens*/ 10);+ child+ .record_token_usage_with_last("child-turn", &previous_usage, &previous_usage)+ .await;++ let tools = harness.tools();+ let create_tool = tool_by_name(&tools, "create_goal");+ create_tool+ .handle(tool_call(+ "create_goal",+ "call-create-first-goal",+ json!({ "objective": "first goal" }),+ ))+ .await?;+ child+ .record_token_usage_with_last(+ "child-turn",+ &input_token_usage(/*input_tokens*/ 35),+ &input_token_usage(/*input_tokens*/ 25),+ )+ .await;+ let completion = tool_call(+ "update_goal",+ "call-complete-first-goal",+ json!({ "status": "complete" }),+ );+ let completed = tool_by_name(&tools, "update_goal")+ .handle(completion.clone())+ .await?;+ assert_eq!(+ json!(25),+ completed.code_mode_result(&completion.payload)["goal"]["tokensUsed"]+ );++ child+ .record_token_usage_with_last(+ "child-turn",+ &input_token_usage(/*input_tokens*/ 55),+ &input_token_usage(/*input_tokens*/ 20),+ )+ .await;+ create_tool+ .handle(tool_call(+ "create_goal",+ "call-create-second-goal",+ json!({ "objective": "replacement goal" }),+ ))+ .await?;+ child+ .record_token_usage_with_last(+ "child-turn",+ &input_token_usage(/*input_tokens*/ 64),+ &input_token_usage(/*input_tokens*/ 9),+ )+ .await;+ harness.stop_turn("turn-1").await;++ let goal = runtime+ .thread_goals()+ .get_thread_goal(thread_id)+ .await?+ .ok_or_else(|| anyhow::anyhow!("replacement goal should exist"))?;+ assert_eq!("replacement goal", goal.objective);+ assert_eq!(9, goal.tokens_used);+ Ok(())+}+#[tokio::test]async fn budget_limited_goal_keeps_accruing_until_turn_stop() -> anyhow::Result<()> {let runtime = test_runtime().await?;@@ -943,8 +1123,7 @@ async fn external_goal_mutation_start_accounts_active_goal_progress() -> anyhow:}#[tokio::test]-async fn goal_service_external_set_active_resets_baseline_without_live_thread() -> anyhow::Result<()>-{+async fn goal_service_external_set_active_preserves_concurrent_usage() -> anyhow::Result<()> {let runtime = test_runtime().await?;let thread_id = test_thread_id()?;seed_thread_metadata(runtime.as_ref(), thread_id).await?;@@ -969,6 +1148,8 @@ async fn goal_service_external_set_active_resets_baseline_without_live_thread()json!({ "objective": "old objective" }),)).await?;+ let child = harness.spawn_child(ThreadId::new()).await?;+ child.start_turn("child-turn", &TokenUsage::default()).await;harness.sink.clear();harness@@ -994,6 +1175,20 @@ async fn goal_service_external_set_active_resets_baseline_without_live_thread()},).await?;+ harness+ .record_token_usage(+ "turn-1",+ &token_usage(+ /*input_tokens*/ 125, /*cached_input_tokens*/ 0,+ /*output_tokens*/ 0, /*reasoning_output_tokens*/ 0,+ /*total_tokens*/ 125,+ ),+ )+ .await;+ let child_usage = input_token_usage(/*input_tokens*/ 23);+ child+ .record_token_usage_with_last("child-turn", &child_usage, &child_usage)+ .await;outcome.apply_runtime_effects(&harness.goal_service).await;harness@@ -1015,7 +1210,7 @@ async fn goal_service_external_set_active_resets_baseline_without_live_thread().get_thread_goal(thread_id).await?.ok_or_else(|| anyhow::anyhow!("goal should exist"))?;- assert_eq!(30, goal.tokens_used);+ assert_eq!(53, goal.tokens_used);Ok(())}@@ -1076,6 +1271,12 @@ async fn thread_resume_rehydrates_active_goal_idle_accounting() -> anyhow::Resullet harness = GoalExtensionHarness::new(runtime.clone(), thread_id).await?;harness.resume_thread().await;+ let child = harness.spawn_child(ThreadId::new()).await?;+ child.start_turn("child-turn", &TokenUsage::default()).await;+ let usage = input_token_usage(/*input_tokens*/ 23);+ child+ .record_token_usage_with_last("child-turn", &usage, &usage)+ .await;tokio::time::sleep(Duration::from_millis(1_100)).await;harness.runtime_handle()@@ -1089,6 +1290,7 @@ async fn thread_resume_rehydrates_active_goal_idle_accounting() -> anyhow::Resul.await?.ok_or_else(|| anyhow::anyhow!("goal should exist"))?;assert_eq!(ThreadGoalStatus::Active, protocol_status(goal.status));+ assert_eq!(23, goal.tokens_used);assert!(goal.time_used_seconds >= 1,"resumed idle accounting should add elapsed wall-clock time"@@ -1098,7 +1300,7 @@ async fn thread_resume_rehydrates_active_goal_idle_accounting() -> anyhow::Resulevent_id: format!("{thread_id}:external-goal-mutation"),turn_id: None,status: ThreadGoalStatus::Active,- tokens_used: 0,+ tokens_used: 23,}],harness.sink.goal_events());@@ -1289,7 +1491,7 @@ fn tool_names(tools: &[Arc<dyn for<'call> ToolExecutor<ToolCall<'call>>>]) -> Ve}struct GoalExtensionHarness {- registry: codex_extension_api::ExtensionRegistry<()>,+ registry: Arc<codex_extension_api::ExtensionRegistry<()>>,session_store: ExtensionData,thread_store: ExtensionData,goal_service: Arc<GoalService>,@@ -1316,8 +1518,8 @@ impl GoalExtensionHarness {max_goal_token_budget: None,},);- let registry = builder.build();- let session_store = ExtensionData::new("session-1");+ let registry = Arc::new(builder.build());+ let session_store = ExtensionData::new(thread_id.to_string());let thread_store = ExtensionData::new(thread_id.to_string());let session_source = SessionSource::Cli;for contributor in registry.thread_lifecycle_contributors() {@@ -1343,6 +1545,49 @@ impl GoalExtensionHarness {})}+ async fn spawn_child(&self, thread_id: ThreadId) -> anyhow::Result<Self> {+ let session_source = SubAgentSource::ThreadSpawn {+ parent_thread_id: ThreadId::from_string(self.thread_store.level_id())?,+ depth: 1,+ agent_path: None,+ agent_nickname: None,+ agent_role: None,+ };+ self.spawn_child_with_source(thread_id, session_source)+ .await+ }++ async fn spawn_child_with_source(+ &self,+ thread_id: ThreadId,+ session_source: SubAgentSource,+ ) -> anyhow::Result<Self> {+ let session_store = ExtensionData::new(self.session_store.level_id());+ let thread_store = ExtensionData::new(thread_id.to_string());+ let session_source = SessionSource::SubAgent(session_source);+ for contributor in self.registry.thread_lifecycle_contributors() {+ contributor+ .on_thread_start(ThreadStartInput {+ config: &(),+ session_source: &session_source,+ persistent_thread_state_available: true,+ environments: &[],+ mcp_resource_client: None,+ extension_metrics: None,+ session_store: &session_store,+ thread_store: &thread_store,+ })+ .await;+ }+ Ok(Self {+ registry: Arc::clone(&self.registry),+ session_store,+ thread_store,+ goal_service: Arc::clone(&self.goal_service),+ sink: Arc::clone(&self.sink),+ })+ }+fn tools(&self) -> Vec<Arc<dyn for<'call> ToolExecutor<ToolCall<'call>>>> {self.registry.tool_contributors()@@ -1388,10 +1633,20 @@ impl GoalExtensionHarness {}async fn record_token_usage(&self, turn_id: &str, usage: &TokenUsage) {+ self.record_token_usage_with_last(turn_id, usage, &TokenUsage::default())+ .await;+ }++ async fn record_token_usage_with_last(+ &self,+ turn_id: &str,+ usage: &TokenUsage,+ last_usage: &TokenUsage,+ ) {let turn_store = ExtensionData::new(turn_id);let token_usage = TokenUsageInfo {total_token_usage: usage.clone(),- last_token_usage: TokenUsage::default(),+ last_token_usage: last_usage.clone(),model_context_window: None,};for contributor in self.registry.token_usage_contributors() {@@ -1603,6 +1858,14 @@ fn token_usage(}}+fn input_token_usage(input_tokens: i64) -> TokenUsage {+ TokenUsage {+ input_tokens,+ total_tokens: input_tokens,+ ..TokenUsage::default()+ }+}+fn protocol_status(status: codex_state::ThreadGoalStatus) -> ThreadGoalStatus {match status {codex_state::ThreadGoalStatus::Active => ThreadGoalStatus::Active,