Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

feat(agent): merge spawn_async_subagent into spawn_subagent

Steven Enamakeld3ff36b1d5bb
diff --git a/app/src/features/conversations/derived/mapDisplayItems.ts b/app/src/features/conversations/derived/mapDisplayItems.ts
index 5445930192..0c3d9c4a2f 100644
--- a/app/src/features/conversations/derived/mapDisplayItems.ts
+++ b/app/src/features/conversations/derived/mapDisplayItems.ts
@@ -405,7 +405,7 @@ export function mapDisplayItems(
/** Tool names that open a delegation — mirrors `findPendingDelegationContext`. */
function isDelegationToolName(name: string): boolean {
return (
- name === 'spawn_subagent' || name === 'spawn_async_subagent' || name.startsWith('delegate_')
+ name === 'spawn_subagent' || name === 'spawn_subagent' || name.startsWith('delegate_')
);
}
diff --git a/app/src/features/conversations/selectors/backgroundProcesses.ts b/app/src/features/conversations/selectors/backgroundProcesses.ts
index e92438e38c..f6b10df5ce 100644
--- a/app/src/features/conversations/selectors/backgroundProcesses.ts
+++ b/app/src/features/conversations/selectors/backgroundProcesses.ts
@@ -6,7 +6,7 @@ import type {
/**
* A background process = a *detached* sub-agent spawned with
- * `spawn_async_subagent` (a fire-and-forget tokio task that keeps running after
+ * `spawn_subagent` (a fire-and-forget tokio task that keeps running after
* the parent turn returns). The backend marks these with `mode: "async"` on the
* `SubagentSpawned` event (every blocking spawn emits `mode: "typed"`), and the
* frontend carries it through on {@link SubagentActivity.mode}. So the whole
diff --git a/app/src/features/conversations/tools/__fixtures__/coreToolNames.json b/app/src/features/conversations/tools/__fixtures__/coreToolNames.json
index 6b3aeec10a..afb4f11f46 100644
--- a/app/src/features/conversations/tools/__fixtures__/coreToolNames.json
+++ b/app/src/features/conversations/tools/__fixtures__/coreToolNames.json
@@ -146,7 +146,7 @@
"skill_registry_uninstall",
"skill_runtime_resolve_runtimes",
"skill_search",
- "spawn_async_subagent",
+ "spawn_subagent",
"spawn_subagent",
"steer_subagent",
"suggest_workflows",
diff --git a/app/src/features/conversations/tools/toolPresentation.ts b/app/src/features/conversations/tools/toolPresentation.ts
index a44d3d1f78..55a11da772 100644
--- a/app/src/features/conversations/tools/toolPresentation.ts
+++ b/app/src/features/conversations/tools/toolPresentation.ts
@@ -240,7 +240,7 @@ export function describeToolCall(input: DescribeToolCallInput): ToolCallPresenta
if (agent) return agent;
}
if (
- (baseName === 'spawn_subagent' || baseName === 'spawn_async_subagent') &&
+ (baseName === 'spawn_subagent' || baseName === 'spawn_subagent') &&
typeof args.agent_id === 'string'
) {
const agent = agentPresentation(args.agent_id, baseName, args, tense, serverDetail);
diff --git a/app/src/features/conversations/tools/toolSpecs.ts b/app/src/features/conversations/tools/toolSpecs.ts
index aad7d069e3..866916ac26 100644
--- a/app/src/features/conversations/tools/toolSpecs.ts
+++ b/app/src/features/conversations/tools/toolSpecs.ts
@@ -298,7 +298,7 @@ export const EXACT_TOOL_SPECS: Record<string, ToolSpec> = {
// ── Agents and delegation ──────────────────────────────────────────────
spawn_subagent: spec('delegateTask', BotIcon, 'agent', { chip: chip.text('agent_id') }),
- spawn_async_subagent: spec('delegateTask', BotIcon, 'agent', { chip: chip.text('agent_id') }),
+ spawn_subagent: spec('delegateTask', BotIcon, 'agent', { chip: chip.text('agent_id') }),
delegate_to: spec('delegateTask', BotIcon, 'agent', { chip: chip.text('agent', 'agent_id') }),
continue_subagent: spec('messageAgent', MessageSquareReplyIcon, 'agent', {
chip: chip.text('agent_id'),
diff --git a/app/src/providers/__tests__/ChatRuntimeProvider.test.tsx b/app/src/providers/__tests__/ChatRuntimeProvider.test.tsx
index 35c2044347..ba51522b61 100644
--- a/app/src/providers/__tests__/ChatRuntimeProvider.test.tsx
+++ b/app/src/providers/__tests__/ChatRuntimeProvider.test.tsx
@@ -159,7 +159,7 @@ describe('ChatRuntimeProvider — dedupe, proactive resolution, mid-turn invaria
{ id: 'ignored', name: 'search', round: 0, status: 'running' },
{
id: 'spawn',
- name: 'spawn_async_subagent',
+ name: 'spawn_subagent',
round: 0,
status: 'running',
argsBuffer: '{"prompt":"Archive preferences."}',
@@ -167,7 +167,7 @@ describe('ChatRuntimeProvider — dedupe, proactive resolution, mid-turn invaria
] as Parameters<typeof findPendingDelegationContext>[0];
expect(findPendingDelegationContext(entries, 0)).toEqual({
- sourceToolName: 'spawn_async_subagent',
+ sourceToolName: 'spawn_subagent',
prompt: 'Archive preferences.',
spawnEntryId: 'spawn',
});
@@ -309,7 +309,7 @@ describe('ChatRuntimeProvider — dedupe, proactive resolution, mid-turn invaria
expect(timeline[0]?.subagent?.prompt).toContain('Research Q3 revenue');
});
- it('collapses a spawn_async_subagent tool-call row into the subagent row', () => {
+ it('collapses a spawn_subagent tool-call row into the subagent row', () => {
const listeners = renderProvider();
act(() => {
@@ -317,7 +317,7 @@ describe('ChatRuntimeProvider — dedupe, proactive resolution, mid-turn invaria
thread_id: 't1',
request_id: 'r1',
round: 0,
- tool_name: 'spawn_async_subagent',
+ tool_name: 'spawn_subagent',
skill_id: 'orchestration',
args: {},
tool_call_id: 'call-spawn-async',
@@ -327,7 +327,7 @@ describe('ChatRuntimeProvider — dedupe, proactive resolution, mid-turn invaria
request_id: 'r1',
round: 0,
tool_call_id: 'call-spawn-async',
- tool_name: 'spawn_async_subagent',
+ tool_name: 'spawn_subagent',
delta: '{"prompt":"Archive these preferences."}',
});
listeners.onSubagentSpawned?.({
@@ -344,7 +344,7 @@ describe('ChatRuntimeProvider — dedupe, proactive resolution, mid-turn invaria
const timeline = store.getState().chatRuntime.toolTimelineByThread['t1'] ?? [];
expect(timeline).toHaveLength(1);
expect(timeline[0]?.name).toBe('subagent:archivist');
- expect(timeline[0]?.sourceToolName).toBe('spawn_async_subagent');
+ expect(timeline[0]?.sourceToolName).toBe('spawn_subagent');
expect(timeline[0]?.subagent?.prompt).toContain('Archive these preferences');
});
diff --git a/app/src/providers/__tests__/assistantUiMessages.approvalProjection.test.ts b/app/src/providers/__tests__/assistantUiMessages.approvalProjection.test.ts
index a3358e9c31..05aea1f7c9 100644
--- a/app/src/providers/__tests__/assistantUiMessages.approvalProjection.test.ts
+++ b/app/src/providers/__tests__/assistantUiMessages.approvalProjection.test.ts
@@ -143,7 +143,7 @@ describe('a parked approval in the runtime projection', () => {
const messages = buildRuntimeMessages([msg({ id: 'a1', sender: 'agent' })], null, {
isRunning: false,
pendingApproval: detached,
- liveTimeline: [tool({ id: 'call-parent', name: 'spawn_async_subagent', status: 'success' })],
+ liveTimeline: [tool({ id: 'call-parent', name: 'spawn_subagent', status: 'success' })],
});
const tail = messages.find(
diff --git a/app/src/services/chatService.ts b/app/src/services/chatService.ts
index 1a358bf24b..b5cb3478fb 100644
--- a/app/src/services/chatService.ts
+++ b/app/src/services/chatService.ts
@@ -682,7 +682,7 @@ export interface SubagentProgressDetail {
/** `null` when the child's cost is not known. */
cost_usd?: number | null;
/**
- * Provider-assigned id of the `spawn_subagent`/`spawn_async_subagent`/
+ * Provider-assigned id of the `spawn_subagent`/`spawn_subagent`/
* `delegate_*` tool call that started this delegation
* (`AgentProgress::SubagentSpawned::parent_call_id`, threaded onto every
* event in the `subagent_*` family — see `crates/openhuman-rpc/src/server/socketio.rs`).
diff --git a/app/src/store/__tests__/chatRuntimeSlice.test.ts b/app/src/store/__tests__/chatRuntimeSlice.test.ts
index 96c6b611ec..1bf5defbfe 100644
--- a/app/src/store/__tests__/chatRuntimeSlice.test.ts
+++ b/app/src/store/__tests__/chatRuntimeSlice.test.ts
@@ -222,7 +222,7 @@ describe('chatRuntimeSlice', () => {
});
/**
- * A detached `spawn_async_subagent` child outlives the turn that spawned it.
+ * A detached `spawn_subagent` child outlives the turn that spawned it.
* Settling it on the parent's `completed` snapshot made the Background tasks
* panel report "none running" — and the row read "Cancelled" — while the
* sub-agent was still making tool calls. Its own `subagent_completed` event
diff --git a/app/src/store/chatRuntimeSlice.ts b/app/src/store/chatRuntimeSlice.ts
index 0672ae94ea..783febc790 100644
--- a/app/src/store/chatRuntimeSlice.ts
+++ b/app/src/store/chatRuntimeSlice.ts
@@ -119,7 +119,7 @@ export interface SubagentActivity {
*/
spawnEventId?: string;
/**
- * Provider-assigned id of the `spawn_subagent`/`spawn_async_subagent`/
+ * Provider-assigned id of the `spawn_subagent`/`spawn_subagent`/
* `delegate_*` tool call that started this delegation
* (`SubagentProgressDetail.parent_call_id` on the `subagent_spawned`
* event). When present, `assistantUiMessages.ts` renders this activity's
@@ -361,7 +361,7 @@ export function findPendingDelegationContext(
const entry = entries[i];
if (entry.status !== 'running' || entry.round !== round) continue;
if (
- ['spawn_subagent', 'spawn_async_subagent'].includes(entry.name) ||
+ ['spawn_subagent', 'spawn_subagent'].includes(entry.name) ||
entry.name.startsWith('delegate_')
) {
return {
@@ -1392,7 +1392,7 @@ export function toolTimelineFromPersisted(
* intact preserves the truthful "was waiting for the user" history — and the
* pulse is already stopped by the row-level `cancelled` above.
*
- * A detached sub-agent (`spawn_async_subagent`, `mode === 'async'`) is the
+ * A detached sub-agent (`spawn_subagent`, `mode === 'async'`) is the
* exception, and the parent's snapshot is never allowed to settle it. It is a
* fire-and-forget task that deliberately outlives the turn that spawned it, so
* the parent's lifecycle says nothing about whether the child is alive — and
diff --git a/crates/openhuman-core/src/agent/README.md b/crates/openhuman-core/src/agent/README.md
index 88cccd6a0b..6ea1ccbb9f 100644
--- a/crates/openhuman-core/src/agent/README.md
+++ b/crates/openhuman-core/src/agent/README.md
@@ -178,7 +178,7 @@ its `AgentStores`. See [session_host/README.md](session_host/README.md).
A parent agent delegates by calling a tool. `spawn_subagent`
([`orchestration/tools/spawn_subagent.rs`](./orchestration/tools/spawn_subagent.rs)) and its siblings
-(`spawn_async_subagent`, `continue_subagent`,
+(`spawn_subagent`, `continue_subagent`,
`steer_subagent`, `wait_subagent`, `close_subagent`) look up the
target `AgentDefinition` and call `subagent_host::run_subagent_with_parent`.
diff --git a/crates/openhuman-core/src/agent/harness/README.md b/crates/openhuman-core/src/agent/harness/README.md
index 5306fa6912..cb56f25efa 100644
--- a/crates/openhuman-core/src/agent/harness/README.md
+++ b/crates/openhuman-core/src/agent/harness/README.md
@@ -99,7 +99,7 @@ turn lifecycle are in `../session_host/`; `run_subagent`,
`AgentDefinitionRegistry`/`ToolScope`.
- `agent/tinyagents/middleware/credential_scrub.rs` calls
`harness::credentials::scrub_credentials` on every tool result.
-- `agent/orchestration/tools/*` (`spawn_subagent`, `spawn_async_subagent`,
+- `agent/orchestration/tools/*` (`spawn_subagent`, `spawn_subagent`,
`continue_subagent`, `steer_subagent`, and friends)
call into `../subagent_host/` and take this module's parent context
explicitly.
diff --git a/crates/openhuman-core/src/agent/orchestration/README.md b/crates/openhuman-core/src/agent/orchestration/README.md
index 8267aa04f8..2daff9c244 100644
--- a/crates/openhuman-core/src/agent/orchestration/README.md
+++ b/crates/openhuman-core/src/agent/orchestration/README.md
@@ -11,7 +11,7 @@ and UI-facing projections.
- Host adapters that dispatch work through `agent::subagent_host::run_subagent`.
- Background sub-agent task tracking, cancellation, steering, completion
delivery, and run-ledger projection.
-- Manual cancellation and steering for detached `spawn_async_subagent` runs.
+- Manual cancellation and steering for detached `spawn_subagent` runs.
- The shared root `ParentExecutionContext` builder used by background tasks.
## Key files
@@ -34,7 +34,7 @@ and UI-facing projections.
## Tools
-The module exposes `spawn_subagent`, `spawn_async_subagent`,
+The module exposes `spawn_subagent`, `spawn_subagent`,
`steer_subagent`, `continue_subagent`,
`close_subagent`, `wait_subagent`, and `list_subagents`.
Archetype delegates provide focused synchronous calls over the live sub-agent host.
diff --git a/crates/openhuman-core/src/agent/orchestration/background_completions.rs b/crates/openhuman-core/src/agent/orchestration/background_completions.rs
index 8db949454b..ada3903057 100644
--- a/crates/openhuman-core/src/agent/orchestration/background_completions.rs
+++ b/crates/openhuman-core/src/agent/orchestration/background_completions.rs
@@ -1,5 +1,5 @@
//! Host adapter over the harness `CompletionRouter` for finished detached
-//! background sub-agents (`spawn_async_subagent`).
+//! background sub-agents (`spawn_subagent`).
//!
//! The queue itself is the harness's: `tinyagents_tasks::CompletionRouter`
//! deduplicates by task id, holds tombstones (collected inline, stopped,
@@ -211,7 +211,7 @@ pub(crate) async fn record_outcome_with_parent_epoch(
let task_id = task_id.into();
let Some(thread_id) = parent_thread_id else {
// Delivery is thread-addressed; a headless spawn has nowhere to land
- // the result. (`spawn_async_subagent` refuses to start one.)
+ // the result. (`spawn_subagent` refuses to start one.)
log::warn!("[background_completions] dropping headless completion task_id={task_id}");
return;
};
diff --git a/crates/openhuman-core/src/agent/orchestration/fleet_tools_tests.rs b/crates/openhuman-core/src/agent/orchestration/fleet_tools_tests.rs
index 6d73a835ce..7073446110 100644
--- a/crates/openhuman-core/src/agent/orchestration/fleet_tools_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/fleet_tools_tests.rs
@@ -9,7 +9,7 @@ fn named(tools: &[&str]) -> ToolScope {
fn named_scope_exposes_only_listed_fleet_tools() {
let set = FleetToolSet::from_scope(
&named(&[
- "spawn_async_subagent",
+ "spawn_subagent",
"list_subagents",
"continue_subagent",
"shell",
diff --git a/crates/openhuman-core/src/agent/orchestration/running_subagents.rs b/crates/openhuman-core/src/agent/orchestration/running_subagents.rs
index 1d60011c48..101eb35f40 100644
--- a/crates/openhuman-core/src/agent/orchestration/running_subagents.rs
+++ b/crates/openhuman-core/src/agent/orchestration/running_subagents.rs
@@ -1,6 +1,6 @@
//! Registry of in-flight async sub-agents that can be **steered** mid-run.
//!
-//! `spawn_async_subagent` runs a child as a detached `tokio` task. On its own
+//! `spawn_subagent` runs a child as a detached `tokio` task. On its own
//! that task is opaque: the parent gets a `task_id` back but has no channel into
//! the running loop and no way to collect the result inline. This registry
//! closes both gaps.
diff --git a/crates/openhuman-core/src/agent/orchestration/running_subagents_tenant_tests.rs b/crates/openhuman-core/src/agent/orchestration/running_subagents_tenant_tests.rs
index f63c1851a2..eb9007eacb 100644
--- a/crates/openhuman-core/src/agent/orchestration/running_subagents_tenant_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/running_subagents_tenant_tests.rs
@@ -230,7 +230,7 @@ async fn unscoped_async_spawn_refuses_before_persisting_a_running_session() {
}
use crate::agent::harness::fork_context::ParentExecutionContext;
use crate::agent::orchestration::subagent_sessions::SubagentSessionStore;
- use crate::agent::orchestration::tools::{SpawnAsyncSubagentDispatch, SpawnAsyncSubagentTool};
+ use crate::agent::orchestration::tools::{SpawnSubagentDispatch, SpawnSubagentTool};
use tinyagents_harness::tool::ToolDispatch;
let _ = crate::agent_registry::host_definition::AgentDefinitionRegistry::init_global_builtins();
let workspace = tempfile::tempdir().unwrap();
@@ -272,7 +272,7 @@ async fn unscoped_async_spawn_refuses_before_persisting_a_running_session() {
tinyagents_harness::context::RunConfig::new("scope-refusal")
.with_thread("scope-refusal-parent"),
);
- let result = SpawnAsyncSubagentDispatch::new(Arc::new(SpawnAsyncSubagentTool::new()))
+ let result = SpawnSubagentDispatch::new(Arc::new(SpawnSubagentTool::new()))
.execute(
&(),
tinyagents_harness::ids::CallId::new("scope-refusal-spawn"),
diff --git a/crates/openhuman-core/src/agent/orchestration/subagent_events.rs b/crates/openhuman-core/src/agent/orchestration/subagent_events.rs
index e0fb315cda..1741a7a488 100644
--- a/crates/openhuman-core/src/agent/orchestration/subagent_events.rs
+++ b/crates/openhuman-core/src/agent/orchestration/subagent_events.rs
@@ -4,7 +4,7 @@
//! `SubagentFailed` / `SubagentAwaitingUser`) used to be hand-constructed and
//! `publish_global`-ed inline across every turn/orchestration path
//! (`tools/dispatch.rs`, `tools/spawn_subagent.rs`,
-//! `tools/spawn_async_subagent.rs`, and `tools/continue_subagent.rs`). That scattered
+//! `tools/spawn_subagent.rs`, and `tools/continue_subagent.rs`). That scattered
//! the ordering/rate-limiting decision across many call sites.
//!
//! This module centralizes construction + publish so there is exactly one place
diff --git a/crates/openhuman-core/src/agent/orchestration/tools.rs b/crates/openhuman-core/src/agent/orchestration/tools.rs
index 0d0b668ebf..ace8121f29 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools.rs
@@ -1,7 +1,7 @@
//! Declares OpenHuman's product orchestration surfaces over TinyAgents.
//!
//! Tools, by role:
-//! - **Spawn**: `spawn_subagent` and `spawn_async_subagent`.
+//! - **Spawn**: `spawn_subagent` and `spawn_subagent`.
//! - **Control**: `steer_subagent`, `continue_subagent`, `close_subagent`,
//! `wait_subagent`, `list_subagents`.
//! - **Delegation**: `ArchetypeDelegationTool`.
@@ -22,8 +22,8 @@ pub(crate) mod awaiting_user;
mod continue_subagent;
#[path = "tools/subagent_dispatch_host.rs"]
mod dispatch;
-#[path = "tools/spawn_async_subagent_surface.rs"]
-mod spawn_async_subagent;
+#[path = "tools/spawn_subagent_surface.rs"]
+mod spawn_subagent;
#[path = "tools/spawn_subagent_surface.rs"]
mod spawn_subagent;
#[path = "tools/subagent_abort_report.rs"]
@@ -61,7 +61,7 @@ pub(crate) fn live_parent_run_context(
pub use archetype_delegation::{ArchetypeDelegationTool, DelegationTarget};
pub(crate) use continue_subagent::ContinueSubagentDispatch;
pub use continue_subagent::ContinueSubagentTool;
-pub(crate) use spawn_async_subagent::SpawnAsyncSubagentDispatch;
-pub use spawn_async_subagent::{scope_spawn_async_subagent_spec, SpawnAsyncSubagentTool};
+pub(crate) use spawn_subagent::SpawnSubagentDispatch;
+pub use spawn_subagent::{scope_spawn_subagent_spec, SpawnSubagentTool};
pub(crate) use spawn_subagent::SpawnSubagentDispatch;
pub use spawn_subagent::SpawnSubagentTool;
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/continue_subagent_host.rs b/crates/openhuman-core/src/agent/orchestration/tools/continue_subagent_host.rs
index acd0d25905..1d2ab265b3 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/continue_subagent_host.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/continue_subagent_host.rs
@@ -79,7 +79,7 @@ impl ContinueSubagentTool {
/// Accepts either the transient `task_id` (`sub-…`) or the durable
/// `subagent_session_id` in the tool's `task_id` argument — the ambient
/// `[active_subagents]` roster advertises both. The resume routes through
- /// `spawn_async_subagent` pinned to the session's `task_key`, so the
+ /// `spawn_subagent` pinned to the session's `task_key`, so the
/// reusable-session machinery reattaches: a `running` worker is steered,
/// an `idle` one is relaunched seeded with its persisted `latest_history`
/// plus the new message, and the finished result is delivered back into
@@ -157,7 +157,7 @@ impl ContinueSubagentTool {
}
let detached_parent =
crate::agent::subagent_host::detached_subagent_parent(live_parent, "async-subagent")?;
- super::spawn_async_subagent::SpawnAsyncSubagentTool::new()
+ super::spawn_subagent::SpawnSubagentTool::new()
.execute_with_live_parent_context(
async_args,
tool_context,
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_async_tests.rs b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_async_tests.rs
index e08c1efbc1..ace29af5dd 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_async_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_async_tests.rs
@@ -125,7 +125,7 @@ impl ToolRunContext for ThreadContext {
#[test]
fn parameters_schema_advertises_fire_and_forget_fields() {
- let tool = SpawnAsyncSubagentTool::new();
+ let tool = SpawnSubagentTool::new();
let schema = tool.parameters_schema();
let required = schema
.get("required")
@@ -472,7 +472,7 @@ fn attach_workflow_proposal_without_proposal_returns_summary_unchanged() {
#[tokio::test]
async fn missing_agent_id_returns_error() {
- let tool = SpawnAsyncSubagentTool::new();
+ let tool = SpawnSubagentTool::new();
let result = tool.execute(json!({ "prompt": "do work" })).await.unwrap();
assert!(result.is_error);
assert!(result.output().contains("agent_id"));
@@ -480,7 +480,7 @@ async fn missing_agent_id_returns_error() {
#[tokio::test]
async fn missing_prompt_returns_error() {
- let tool = SpawnAsyncSubagentTool::new();
+ let tool = SpawnSubagentTool::new();
let result = tool
.execute(json!({ "agent_id": "archivist" }))
.await
@@ -490,7 +490,7 @@ async fn missing_prompt_returns_error() {
}
/// B40 / Gap 4: a delegating agent (e.g. the orchestrator) calling
-/// `spawn_async_subagent` directly from a thread-less context (flow
+/// `spawn_subagent` directly from a thread-less context (flow
/// `agent` node, CLI, cron) must get a clear, actionable error instead of
/// silently accepting the spawn and later dropping its result in
/// `background_delivery`'s "headless batch" path. Sets up a real parent
@@ -504,7 +504,7 @@ async fn errors_clearly_when_no_parent_thread_for_delivery() {
let _ = AgentDefinitionRegistry::init_global_builtins();
let workspace = tempfile::TempDir::new().expect("workspace");
- let result = SpawnAsyncSubagentTool::new()
+ let result = SpawnSubagentTool::new()
.execute_under_parent(
json!({
"agent_id": "task_manager_agent",
@@ -550,7 +550,7 @@ async fn guard_does_not_fire_when_parent_thread_is_bound() {
let workspace = tempfile::TempDir::new().expect("workspace");
let thread = ThreadContext("t-parent");
- let result = SpawnAsyncSubagentTool::new()
+ let result = SpawnSubagentTool::new()
.execute_under_parent(
json!({
"agent_id": "task_manager_agent",
@@ -606,7 +606,7 @@ fn parent_context(workspace_dir: &Path) -> ParentExecutionContext {
/// parent may dispatch, sorted and deduplicated, and says so.
#[test]
fn scoped_instance_advertises_exactly_the_allowlist() {
- let tool = SpawnAsyncSubagentTool::scoped(vec![
+ let tool = SpawnSubagentTool::scoped(vec![
"workflow_builder".to_string(),
"agent_memory".to_string(),
"workflow_builder".to_string(),
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_projection.rs b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_projection.rs
index 102cc80893..b98b0da131 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_projection.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_projection.rs
@@ -7,7 +7,7 @@
// synchronous alternative (`spawn_subagent` with `blocking: true`, or a `delegate_*`
// tool). Both of those self-heal to blocking dispatch in this situation rather than
// reaching this guard — see the `has_delivery_thread` checks in `spawn_subagent_surface.rs` and
-// `subagent_dispatch_host.rs::dispatch_subagent`. Only a *direct* `spawn_async_subagent` call lands
+// `subagent_dispatch_host.rs::dispatch_subagent`. Only a *direct* `spawn_subagent` call lands
// here.
fn refuse_missing_delivery_thread(
parent_thread_id: Option<&str>,
@@ -16,14 +16,14 @@ fn refuse_missing_delivery_thread(
) -> Option<ToolResult> {
if parent_thread_id.is_none() {
log::warn!(
- "[spawn_async_subagent] refusing fire-and-forget spawn with no delivery thread \
+ "[spawn_subagent] refusing fire-and-forget spawn with no delivery thread \
parent={} requested={} — directing caller to synchronous delegation (flow node / \
CLI / cron context, background result would be discarded)",
parent_agent_id,
requested_agent_id
);
return Some(ToolResult::error(
- "spawn_async_subagent: no parent chat thread available to deliver the result \
+ "spawn_subagent: no parent chat thread available to deliver the result \
into (this looks like a flow node, CLI, or cron run rather than an interactive \
chat turn). Fire-and-forget delegation has nowhere to land its result here and \
the sub-agent's work would be silently discarded. Use synchronous delegation \
@@ -63,20 +63,20 @@ fn accepted_spawn_result(
let payload_json = match serde_json::to_string(&payload) {
Ok(serialized) => {
log::debug!(
- "[spawn_async_subagent] serialized async reference payload bytes={}",
+ "[spawn_subagent] serialized async reference payload bytes={}",
serialized.len()
);
serialized
}
Err(error) => {
log::debug!(
- "[spawn_async_subagent] failed to serialize async reference payload: {}",
+ "[spawn_subagent] failed to serialize async reference payload: {}",
error
);
"{}".to_string()
}
};
- log::debug!("[spawn_async_subagent] formatting accepted response");
+ log::debug!("[spawn_subagent] formatting accepted response");
ToolResult::success(format_async_subagent_accepted(
payload["agent_id"].as_str().unwrap_or("subagent"),
&payload_json,
@@ -87,12 +87,12 @@ fn accepted_spawn_result(
fn refuse_empty_spawn_args(agent_id: &str, prompt: &str) -> Option<ToolResult> {
if agent_id.is_empty() {
return Some(ToolResult::error(
- "spawn_async_subagent: `agent_id` is required",
+ "spawn_subagent: `agent_id` is required",
));
}
if prompt.is_empty() {
return Some(ToolResult::error(
- "spawn_async_subagent: `prompt` is required",
+ "spawn_subagent: `prompt` is required",
));
}
None
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_request.rs b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_request.rs
index d1f89063d2..8862400963 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_request.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_request.rs
@@ -1,7 +1,7 @@
-// Argument decoding for `spawn_async_subagent`.
+// Argument decoding for `spawn_subagent`.
//
-// Textually included into `spawn_async_subagent_surface.rs` beside
-// `spawn_async_subagent_host_impl.rs`, so it shares that module's imports. Split
+// Textually included into `spawn_subagent_surface.rs` beside
+// `spawn_subagent_host_impl.rs`, so it shares that module's imports. Split
// out because the execute fragment had grown to 847 lines against the layout
// gate's pin, and this prologue is the one phase of that function that is a
// pure function of `args` — every other phase closes over the run context, the
@@ -14,7 +14,7 @@
// widening another module's surface. That is left as follow-up rather than
// forced through here.
-/// The `spawn_async_subagent` arguments, decoded and normalised.
+/// The `spawn_subagent` arguments, decoded and normalised.
///
/// Trimmed, with blank strings treated as absent, exactly as the inline code
/// did — `task_title` keeps its default and `task_key` is normalised through
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_tests.rs b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_tests.rs
index d128c05d23..d4b3a00b14 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_tests.rs
@@ -268,7 +268,7 @@ async fn legacy_archetype_alias_is_normalized_to_agent_id() {
/// B40: with no chat thread bound, async-by-default delegation has nowhere
/// to deliver a result, so `spawn_subagent` must self-heal to blocking
-/// dispatch rather than forwarding into `spawn_async_subagent`'s
+/// dispatch rather than forwarding into `spawn_subagent`'s
/// thread-less guard — otherwise the guard's own advice ("use
/// `spawn_subagent`") would loop straight back into the guard. Asserted
/// via which tool owns the downstream error.
@@ -285,7 +285,7 @@ async fn async_default_self_heals_to_blocking_without_delivery_thread() {
let out = result.output();
assert!(
- !out.contains("spawn_async_subagent"),
+ !out.contains("spawn_subagent"),
"thread-less spawn_subagent must not route into the async tool: {out}"
);
assert!(
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/subagent_abort_report.rs b/crates/openhuman-core/src/agent/orchestration/tools/subagent_abort_report.rs
index fab6ef3dcf..81d1a3b03d 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/subagent_abort_report.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/subagent_abort_report.rs
@@ -1,6 +1,6 @@
//! Report a detached sub-agent that was aborted before it could report itself.
//!
-//! A background sub-agent (`spawn_async_subagent`) sends its own terminal
+//! A background sub-agent (`spawn_subagent`) sends its own terminal
//! `SubagentCompleted` / `SubagentFailed` on the parent's progress channel, and
//! that one event settles everything downstream: the web bridge emits
//! `subagent_failed` to the chat card, the turn-state mirror marks the saved
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/subagent_dispatch_host.rs b/crates/openhuman-core/src/agent/orchestration/tools/subagent_dispatch_host.rs
index 7953a48cb0..d49582d6bc 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/subagent_dispatch_host.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/subagent_dispatch_host.rs
@@ -261,7 +261,7 @@ pub(crate) async fn dispatch_subagent_with_live_parent(
(result will be delivered as a follow-up turn)",
definition.id
);
- // Box the forwarded future: `SpawnAsyncSubagentTool`'s
+ // Box the forwarded future: `SpawnSubagentTool`'s
// `execute_with_context` future is large, and embedding it inline
// in every delegation tool's future (which itself nests inside
// agent-turn futures) overflows the test-thread stack on deep
@@ -271,7 +271,7 @@ pub(crate) async fn dispatch_subagent_with_live_parent(
live_parent,
"async-subagent",
)?;
- super::spawn_async_subagent::SpawnAsyncSubagentTool::new()
+ super::spawn_subagent::SpawnSubagentTool::new()
.execute_with_live_parent_context(
async_args,
tool_context,
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_driver_tests.rs b/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_driver_tests.rs
index 8da3c6512a..affeaa66e4 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_driver_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_driver_tests.rs
@@ -82,7 +82,7 @@ async fn failed_steer_of_running_reused_session_does_not_create_second_child() {
tinyagents_harness_tools::subagents::SubAgentJobRegistry,
>(&live.data.dispatch_ctx());
let jobs_before = jobs.list().len();
- let result = crate::agent::orchestration::tools::SpawnAsyncSubagentTool::new()
+ let result = crate::agent::orchestration::tools::SpawnSubagentTool::new()
.execute_with_live_parent_context(
json!({
"agent_id": "task_manager_agent",
@@ -221,7 +221,7 @@ async fn force_fresh_cancels_old_driver_before_creating_a_new_session() {
)
.expect("detached child context")
.with_cancellation(cancellation);
- crate::agent::orchestration::tools::SpawnAsyncSubagentTool::new()
+ crate::agent::orchestration::tools::SpawnSubagentTool::new()
.execute_with_live_parent_context(args, None, live.data.child(), detached)
.await
.expect("spawn tool executes")
@@ -449,7 +449,7 @@ async fn stopped_async_spawn_is_refused_before_progress_or_session_effects() {
.expect("detached child context")
.with_cancellation(detached_data.cancellation.clone());
- let result = crate::agent::orchestration::tools::SpawnAsyncSubagentTool::new()
+ let result = crate::agent::orchestration::tools::SpawnSubagentTool::new()
.execute_with_live_parent_context(
json!({
"agent_id": "task_manager_agent",
@@ -585,7 +585,7 @@ async fn deleted_thread_marker_survives_router_restart_and_refuses_async_spawn()
)
.expect("detached child context")
.with_cancellation(detached_data.cancellation.clone());
- let result = crate::agent::orchestration::tools::SpawnAsyncSubagentTool::new()
+ let result = crate::agent::orchestration::tools::SpawnSubagentTool::new()
.execute_with_live_parent_context(
json!({
"agent_id": "task_manager_agent",
@@ -693,7 +693,7 @@ async fn detached_registration_failure_finishes_the_announced_product_card() {
.expect("the already-detached invocation is allowed")
.with_cancellation(detached_data.cancellation.clone());
- let result = crate::agent::orchestration::tools::SpawnAsyncSubagentTool::new()
+ let result = crate::agent::orchestration::tools::SpawnSubagentTool::new()
.execute_with_live_parent_context(
json!({
"agent_id": "task_manager_agent",
diff --git a/crates/openhuman-core/src/agent/registration.rs b/crates/openhuman-core/src/agent/registration.rs
index 664bd8dd7f..cbab2ea0b9 100644
--- a/crates/openhuman-core/src/agent/registration.rs
+++ b/crates/openhuman-core/src/agent/registration.rs
@@ -1,7 +1,7 @@
//! Registration of agent dialogue and delegation tools.
use super::orchestration::tools::{
- CloseSubagentTool, ContinueSubagentTool, ListSubagentsTool, SpawnAsyncSubagentTool,
+ CloseSubagentTool, ContinueSubagentTool, ListSubagentsTool, SpawnSubagentTool,
SpawnSubagentTool, SteerSubagentTool, WaitSubagentTool,
};
use super::tools::{PlanExitTool, TodoTool};
@@ -23,7 +23,7 @@ pub(crate) fn dialogue_tools(action_dir: &Path, root_config: &Config) -> Vec<Box
// returns a single text result. See
// `agent::subagent_host` for the dispatch path.
Box::new(SpawnSubagentTool::new()),
- Box::new(SpawnAsyncSubagentTool::new()),
+ Box::new(SpawnSubagentTool::new()),
// Interactive clarification early-exit. Sub-agents pause on this tool
// (checkpoint → `AwaitingUser`, see `subagent_host`) and
// the orchestrator resumes them via `continue_subagent` (#4291).
diff --git a/crates/openhuman-core/src/agent/session_host/builder/builder_build.rs b/crates/openhuman-core/src/agent/session_host/builder/builder_build.rs
index 15106c3b4c..eb95041ecd 100644
--- a/crates/openhuman-core/src/agent/session_host/builder/builder_build.rs
+++ b/crates/openhuman-core/src/agent/session_host/builder/builder_build.rs
@@ -17,7 +17,7 @@ impl SessionHostBuilder {
.tools
.ok_or_else(|| anyhow::anyhow!("tools are required"))?;
// Advertise only the spawnable ids on the wire: see
- // `SpawnAsyncSubagentTool::scoped` for why the spec-view narrowing
+ // `SpawnSubagentTool::scoped` for why the spec-view narrowing
// alone did not reach a native-tool-calling provider.
let spawn_scope_id = self
.session_definition
@@ -29,15 +29,15 @@ impl SessionHostBuilder {
if !allowed.is_empty() {
if let Some(slot) = tools
.iter_mut()
- .find(|tool| tool.name() == "spawn_async_subagent")
+ .find(|tool| tool.name() == "spawn_subagent")
{
tracing::debug!(
agent = %agent_id,
ids = allowed.len(),
- "[tools] scoping spawn_async_subagent schema to the subagent allowlist"
+ "[tools] scoping spawn_subagent schema to the subagent allowlist"
);
*slot = Box::new(
- crate::agent::orchestration::tools::SpawnAsyncSubagentTool::scoped(allowed),
+ crate::agent::orchestration::tools::SpawnSubagentTool::scoped(allowed),
);
}
}
diff --git a/crates/openhuman-core/src/agent/session_host/builder/builder_tests_tool_spec_views_tests.rs b/crates/openhuman-core/src/agent/session_host/builder/builder_tests_tool_spec_views_tests.rs
index 70af683dd5..d77f253659 100644
--- a/crates/openhuman-core/src/agent/session_host/builder/builder_tests_tool_spec_views_tests.rs
+++ b/crates/openhuman-core/src/agent/session_host/builder/builder_tests_tool_spec_views_tests.rs
@@ -81,10 +81,10 @@ fn the_three_spec_views_share_their_leaf_schemas() {
}
// Same exception, same reason: the spawn enum is narrowed to this
// agent's `[subagents]` allowlist, so it is a per-session copy.
- if spec.name == "spawn_async_subagent" {
+ if spec.name == "spawn_subagent" {
assert!(
!shared,
- "`spawn_async_subagent` must be scoped into its own allocation"
+ "`spawn_subagent` must be scoped into its own allocation"
);
let ids = spec
.parameters
@@ -117,7 +117,7 @@ fn the_three_spec_views_share_their_leaf_schemas() {
);
assert!(
saw_scoped_spawn,
- "the orchestrator advertises `spawn_async_subagent`, so its enum must have been narrowed"
+ "the orchestrator advertises `spawn_subagent`, so its enum must have been narrowed"
);
}
diff --git a/crates/openhuman-core/src/agent/session_host/builder/mod.rs b/crates/openhuman-core/src/agent/session_host/builder/mod.rs
index 4ae675c953..71e1b63485 100644
--- a/crates/openhuman-core/src/agent/session_host/builder/mod.rs
+++ b/crates/openhuman-core/src/agent/session_host/builder/mod.rs
@@ -149,12 +149,12 @@ pub(super) fn visible_tool_specs_for_policy(
})
.cloned()
.filter_map(|mut spec| {
- if spec.name == "spawn_async_subagent" {
+ if spec.name == "spawn_subagent" {
// Same narrowing for the spawn enum: advertise only the ids
// this agent's `[subagents]` allowlist lets `execute` dispatch.
let allowed = allowed_subagent_ids_for(&tool_policy.profile.agent_id);
if !allowed.is_empty() {
- crate::agent::orchestration::tools::scope_spawn_async_subagent_spec(
+ crate::agent::orchestration::tools::scope_spawn_subagent_spec(
Arc::make_mut(&mut spec),
&allowed,
);
diff --git a/crates/openhuman-core/src/agent/subagent_host/lifecycle.rs b/crates/openhuman-core/src/agent/subagent_host/lifecycle.rs
index 98c1ad4d3d..9f45ed7f92 100644
--- a/crates/openhuman-core/src/agent/subagent_host/lifecycle.rs
+++ b/crates/openhuman-core/src/agent/subagent_host/lifecycle.rs
@@ -350,7 +350,7 @@ async fn invoke_driver_tool_with_request(
let request_task_id = task_id.clone();
let request_continuation = continuation;
let dispatcher = DriverSubAgentTool::new(
- "spawn_async_subagent",
+ "spawn_subagent",
"Host-prepared asynchronous subagent invocation.",
bundle.driver.clone(),
move |_state: &(), parent, args, _call_id| {
diff --git a/crates/openhuman-core/src/agent/tinyagents/host/run_context_tests.rs b/crates/openhuman-core/src/agent/tinyagents/host/run_context_tests.rs
index a82d0fbc6b..b6544c9365 100644
--- a/crates/openhuman-core/src/agent/tinyagents/host/run_context_tests.rs
+++ b/crates/openhuman-core/src/agent/tinyagents/host/run_context_tests.rs
@@ -277,7 +277,7 @@ fn stale_parent_snapshot() -> ParentExecutionContext {
/// `on_progress.is_some()` proves *presence*, not *identity*: a bind that
/// installed some other, freshly created channel satisfies it just as happily,
/// and that is the miswiring that actually ships. Production reads this exact
-/// field one clone away — `spawn_async_subagent_execute.rs` opens with
+/// field one clone away — `spawn_subagent_execute.rs` opens with
/// `let progress_sink = parent.on_progress.clone();` — so delivery onto this
/// receiver is what "the panel will see the spawn" reduces to.
fn assert_bound_sink_is_this_runs_channel(
diff --git a/crates/openhuman-core/src/agent/tinyagents/tool_registration.rs b/crates/openhuman-core/src/agent/tinyagents/tool_registration.rs
index c5847cb332..7c76022cc3 100644
--- a/crates/openhuman-core/src/agent/tinyagents/tool_registration.rs
+++ b/crates/openhuman-core/src/agent/tinyagents/tool_registration.rs
@@ -19,7 +19,7 @@ use tinyinference_llm::model::ChatModel;
use tinytools::{Tool, ToolCallOptions, ToolResult, ToolRunContext};
use crate::agent::orchestration::tools::{
- ContinueSubagentDispatch, DelegationDispatch, SpawnAsyncSubagentDispatch, SpawnSubagentDispatch,
+ ContinueSubagentDispatch, DelegationDispatch, SpawnSubagentDispatch, SpawnSubagentDispatch,
};
use crate::agent::tinyagents::host::run_context::HostOperationContext;
use crate::agent::tinyagents::host::OpenHumanRunContext;
@@ -115,7 +115,7 @@ pub(crate) fn typed_dispatch_for(
delegation_target: Option<String>,
) -> Option<Arc<dyn ToolDispatch<(), OpenHumanRunContext>>> {
let dispatch: Arc<dyn ToolDispatch<(), OpenHumanRunContext>> = match name {
- "spawn_async_subagent" => Arc::new(SpawnAsyncSubagentDispatch::new(adapter)),
+ "spawn_subagent" => Arc::new(SpawnSubagentDispatch::new(adapter)),
"spawn_subagent" => Arc::new(SpawnSubagentDispatch::new(adapter)),
"continue_subagent" => Arc::new(ContinueSubagentDispatch::new(adapter)),
"memory" => Arc::new(LiveToolContextDispatch::new(adapter)),
diff --git a/crates/openhuman-core/src/agent_registry/agents/loader_tests_builtin_registration_tests.rs b/crates/openhuman-core/src/agent_registry/agents/loader_tests_builtin_registration_tests.rs
index f72c061f44..06e0449414 100644
--- a/crates/openhuman-core/src/agent_registry/agents/loader_tests_builtin_registration_tests.rs
+++ b/crates/openhuman-core/src/agent_registry/agents/loader_tests_builtin_registration_tests.rs
@@ -259,7 +259,7 @@ fn master_agent_has_coding_hint_and_named_tools() {
// system turn, so there is nothing to collect and nothing to
// block on.
for required in [
- "spawn_async_subagent",
+ "spawn_subagent",
"list_subagents",
"continue_subagent",
] {
diff --git a/crates/openhuman-core/src/agent_registry/agents/orchestrator/agent.toml b/crates/openhuman-core/src/agent_registry/agents/orchestrator/agent.toml
index d7e0e280a9..176c96b6b4 100644
--- a/crates/openhuman-core/src/agent_registry/agents/orchestrator/agent.toml
+++ b/crates/openhuman-core/src/agent_registry/agents/orchestrator/agent.toml
@@ -219,7 +219,7 @@ named = [
"storage_list_files",
"storage_get_link",
# Sub-agent surface, deliberately three tools (#5701). A sub-agent is
- # always async: `spawn_async_subagent` returns a task id immediately and
+ # always async: `spawn_subagent` returns a task id immediately and
# the runner delivers the result back on an idle system turn via
# `orchestration::background_delivery`. Nothing has to block for it, so
# the collection surface that used to sit here — `wait`, `wait_loop`,
@@ -230,7 +230,7 @@ named = [
# were fleet-management affordances for a fleet the model no longer
# enumerates; a worker that needs different instructions is cheaper to
# respawn, and idle sessions are reaped against the registry cap anyway.
- "spawn_async_subagent",
+ "spawn_subagent",
# Fleet awareness. Re-enumerates the workers this parent has in flight
# (running / awaiting_user / completed-uncollected / failed) plus reusable
# durable sessions — the recovery move when the `[async_subagent_ref]`
diff --git a/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt.md b/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt.md
index 6406fcffdb..2562598696 100644
--- a/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt.md
+++ b/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt.md
@@ -10,12 +10,12 @@ First match wins:
- Code, settings, crypto, OpenHuman help: `use_skill` `coding`/`system`/`web3`/`docs` first; edit and verify in the same turn.
- MCP: server tools come from `tool_search`; never guess their arguments.<!--route:mcp-->
- Specialists: delegate tools or `use_skill`. Act on a returned `## Handoff Plan` yourself; distill replies, never paste them.
-- Reminders: skill `scheduling`, with a yes on exact timing first. Build or edit a workflow: spawn `workflow_builder` with `spawn_async_subagent`; find one: `flow_discovery`.
+- Reminders: skill `scheduling`, with a yes on exact timing first. Build or edit a workflow: spawn `workflow_builder` with `spawn_subagent`; find one: `flow_discovery`.
## Sub-agents
- `[active_subagents]` is the truth about workers; never spawn a duplicate.
-- `spawn_async_subagent` only for work this reply doesn't need. Fan-out is just several spawns in one message; they run concurrently.
+- `spawn_subagent` only for work this reply doesn't need. Fan-out is just several spawns in one message; they run concurrently.
- A result that gates this reply needs a delegate with `blocking: true`.
- `awaiting_user` workers resume with `continue_subagent`; a `failed` one produced nothing: say so.
diff --git a/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt_tests_installed_skills_tests.rs b/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt_tests_installed_skills_tests.rs
index 5b433756f2..f266d6a9fb 100644
--- a/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt_tests_installed_skills_tests.rs
+++ b/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt_tests_installed_skills_tests.rs
@@ -79,7 +79,7 @@ fn render_installed_skills_empty_is_omitted() {
#[test]
fn prompt_routes_result_gating_tasks_to_synchronous_delegation() {
// Regression for #4681: a "critique it before you finalize" task was
- // dispatched via fire-and-forget `spawn_async_subagent`, so the turn
+ // dispatched via fire-and-forget `spawn_subagent`, so the turn
// finalized before the critique ran. The orchestrator prompt must
// explicitly route result-gating work to a synchronous/awaited path.
assert!(
@@ -87,13 +87,13 @@ fn prompt_routes_result_gating_tasks_to_synchronous_delegation() {
"orchestrator prompt must carry the result-gating delegation rule"
);
// The only primitive that returns inside the turn is a blocking
- // `delegate_*` specialist. `spawn_async_subagent` has no `blocking`
+ // `delegate_*` specialist. `spawn_subagent` has no `blocking`
// parameter, and the prompt used to claim it did; make sure that claim
// never comes back.
for line in ARCHETYPE.lines() {
assert!(
- !(line.contains("spawn_async_subagent") && line.contains("blocking: true")),
- "spawn_async_subagent has no `blocking` argument: {line}"
+ !(line.contains("spawn_subagent") && line.contains("blocking: true")),
+ "spawn_subagent has no `blocking` argument: {line}"
);
}
}
diff --git a/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt_tests_session_routing_tests.rs b/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt_tests_session_routing_tests.rs
index 07ab79b556..7ba2ea54aa 100644
--- a/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt_tests_session_routing_tests.rs
+++ b/crates/openhuman-core/src/agent_registry/agents/orchestrator/prompt_tests_session_routing_tests.rs
@@ -106,7 +106,7 @@ fn prompt_routes_workflow_authoring_to_the_builder_not_use_skill() {
// before it discovers the wall.
assert!(
ARCHETYPE.contains(
- "Build or edit a workflow: spawn `workflow_builder` with `spawn_async_subagent`"
+ "Build or edit a workflow: spawn `workflow_builder` with `spawn_subagent`"
),
"orchestrator prompt must carry the workflow routing rule and name the spawn to make"
);
diff --git a/crates/openhuman-core/src/agent_runs/subagent_control.rs b/crates/openhuman-core/src/agent_runs/subagent_control.rs
index 614072a330..1eff76f883 100644
--- a/crates/openhuman-core/src/agent_runs/subagent_control.rs
+++ b/crates/openhuman-core/src/agent_runs/subagent_control.rs
@@ -1,5 +1,5 @@
//! Controller schema + JSON-RPC dispatcher for user-driven control of detached
-//! background sub-agents (`spawn_async_subagent`).
+//! background sub-agents (`spawn_subagent`).
//!
//! Exposes `openhuman.subagent_cancel`: the frontend "Cancel" affordance in the
//! background-tasks drawer calls this to abort a still-running detached
diff --git a/crates/openhuman-core/src/agent_runs/subagent_finalize.rs b/crates/openhuman-core/src/agent_runs/subagent_finalize.rs
index 04efe8696e..743d802929 100644
--- a/crates/openhuman-core/src/agent_runs/subagent_finalize.rs
+++ b/crates/openhuman-core/src/agent_runs/subagent_finalize.rs
@@ -2,7 +2,7 @@
//!
//! # Why this exists
//!
-//! Every spawn path (`spawn_subagent`, `spawn_async_subagent`,
+//! Every spawn path (`spawn_subagent`, `spawn_subagent`,
//! `continue_subagent`, `dispatch`) creates an
//! `agent_runs` row at `status = "running"` and, on completion or user-input
//! pause, fires **both**:
@@ -15,7 +15,7 @@
//! [`progress_bridge`](crate::web_chat::progress_bridge),
//! which consumes that progress channel. That works for synchronous subagents
//! (they finish inside the turn, sink still alive) but **leaks** for detached
-//! `spawn_async_subagent` runs: they outlive the parent turn, so when they
+//! `spawn_subagent` runs: they outlive the parent turn, so when they
//! finish the progress sink is already dropped and `let _ = tx.send(...)` fails
//! silently. The ledger row stays `running` forever, and every thread reopen
//! re-renders it as a perpetual agent timeline row.
diff --git a/crates/openhuman-core/src/core/runtime/bootstrap.rs b/crates/openhuman-core/src/core/runtime/bootstrap.rs
index 6da34206f7..42016c4884 100644
--- a/crates/openhuman-core/src/core/runtime/bootstrap.rs
+++ b/crates/openhuman-core/src/core/runtime/bootstrap.rs
@@ -122,7 +122,7 @@ pub(crate) async fn bootstrap_core_runtime(
}
// --- Run-ledger recovery -------------------------------------------
- // Detached sub-agent runs (`spawn_async_subagent`) from a previous process
+ // Detached sub-agent runs (`spawn_subagent`) from a previous process
// are gone with that process. Any `agent_runs` row still marked `running`
// at boot is orphaned — its driver died without firing a terminal event, so
// the finalizer never settled it. Stamp such rows `interrupted` so they stop
diff --git a/crates/openhuman-core/src/core/runtime/subscribers.rs b/crates/openhuman-core/src/core/runtime/subscribers.rs
index 9d396fd24b..dbed4a3a79 100644
--- a/crates/openhuman-core/src/core/runtime/subscribers.rs
+++ b/crates/openhuman-core/src/core/runtime/subscribers.rs
@@ -427,10 +427,10 @@ pub(super) fn register_domain_subscribers(
// `run_tool_call_loop` directly.
crate::agent::bus::register_agent_handlers();
// Background-completion delivery: when a detached sub-agent
- // (spawn_async_subagent) finishes, surface its result back into the
+ // (spawn_subagent) finishes, surface its result back into the
// originating chat as an idle-gated, batched, system-injected turn.
crate::agent::orchestration::background_delivery::register_background_delivery();
- // Run-ledger finalizer: detached `spawn_async_subagent` runs outlive
+ // Run-ledger finalizer: detached `spawn_subagent` runs outlive
// their parent turn, so their terminal `AgentProgress` never reaches
// the per-turn progress bridge that settles the ledger. This
// global-bus subscriber settles `agent_runs` from
diff --git a/crates/openhuman-core/src/flows/tinyflows/caps/agent.rs b/crates/openhuman-core/src/flows/tinyflows/caps/agent.rs
index 2c4224a422..a7867e49b1 100644
--- a/crates/openhuman-core/src/flows/tinyflows/caps/agent.rs
+++ b/crates/openhuman-core/src/flows/tinyflows/caps/agent.rs
@@ -322,9 +322,9 @@ impl OpenHumanAgentRunner {
/// **Synchronous only (B40 / Gap 4).** A flow `agent` node runs here with
/// no explicit chat thread on its run context. If the
/// agent it runs is a delegating agent (e.g. the orchestrator) and
- /// calls `spawn_async_subagent` directly, the tool now refuses (see the
+ /// calls `spawn_subagent` directly, the tool now refuses (see the
/// `parent_thread_id.is_none()` guard in
- /// `agent_orchestration::tools::spawn_async_subagent`) rather than
+ /// `agent_orchestration::tools::spawn_subagent`) rather than
/// silently discarding the background result once it finishes —
/// `background_delivery` has nowhere to deliver it without a thread id.
/// This module does not bridge async subagent delivery into flow runs.
diff --git a/crates/openhuman-core/src/profiles/provider_settings_tests.rs b/crates/openhuman-core/src/profiles/provider_settings_tests.rs
index 386084cdc5..6682ba4a75 100644
--- a/crates/openhuman-core/src/profiles/provider_settings_tests.rs
+++ b/crates/openhuman-core/src/profiles/provider_settings_tests.rs
@@ -81,7 +81,7 @@ fn rejects_collisions_duplicates_unsafe_identifiers_and_alias_chains() {
" ",
"shell",
"spawn_subagent",
- "spawn_async_subagent",
+ "spawn_subagent",
"continue_subagent",
"memory",
"show_page",
diff --git a/crates/openhuman-core/src/security/approval/gate_intercept.rs b/crates/openhuman-core/src/security/approval/gate_intercept.rs
index d003638198..cee2013616 100644
--- a/crates/openhuman-core/src/security/approval/gate_intercept.rs
+++ b/crates/openhuman-core/src/security/approval/gate_intercept.rs
@@ -264,7 +264,7 @@ impl ApprovalGate {
// so the two are identical whenever both are present. They diverge only
// when a turn is detached from the chat turn that started it and keeps
// the origin but not the approval context — most importantly
- // an async-delegated sub-agent (`spawn_async_subagent`, reached when the
+ // an async-delegated sub-agent (`spawn_subagent`, reached when the
// orchestrator routes "remind me…" to `scheduler_agent`): the origin
// travels but the chat context does not (`detached_child`). Without the fallback the gate
// parks with `thread_id: None`, the web-channel surface drops the
diff --git a/crates/openhuman-core/src/security/approval/gate_subagent_tests.rs b/crates/openhuman-core/src/security/approval/gate_subagent_tests.rs
index 123a3d22c4..fc2576de45 100644
--- a/crates/openhuman-core/src/security/approval/gate_subagent_tests.rs
+++ b/crates/openhuman-core/src/security/approval/gate_subagent_tests.rs
@@ -77,7 +77,7 @@ async fn an_async_subagent_park_reaches_the_parent_thread_detached_with_a_short_
let before = chrono::Utc::now();
let g = gate.clone();
// Origin propagated, the chat approval context not — the state
- // `spawn_async_subagent` leaves its detached child in.
+ // `spawn_subagent` leaves its detached child in.
let handle = tokio::spawn(async move {
turn_origin::with_origin(
async_subagent_origin("thread-parent"),
diff --git a/crates/openhuman-core/src/security/approval/gate_ttl_and_triage_tests.rs b/crates/openhuman-core/src/security/approval/gate_ttl_and_triage_tests.rs
index 87b4f7c17c..e38643d878 100644
--- a/crates/openhuman-core/src/security/approval/gate_ttl_and_triage_tests.rs
+++ b/crates/openhuman-core/src/security/approval/gate_ttl_and_triage_tests.rs
@@ -54,7 +54,7 @@ async fn pending_for_thread_tracks_request_under_chat_context_and_clears() {
}
/// Regression for #5499: an async-delegated sub-agent carries the `WebChat`
-/// origin across the `tokio::spawn` boundary (`spawn_async_subagent` calls
+/// origin across the `tokio::spawn` boundary (`spawn_subagent` calls
/// `turn_origin::propagate`) but NOT the chat approval context.
/// Before the origin-routing fallback the gate parked with `thread_id:
/// None`, the web-channel surface dropped the `ApprovalRequested` event
diff --git a/crates/openhuman-core/src/security/turn_origin.rs b/crates/openhuman-core/src/security/turn_origin.rs
index 5e9ae7f4c3..f5ec94d60a 100644
--- a/crates/openhuman-core/src/security/turn_origin.rs
+++ b/crates/openhuman-core/src/security/turn_origin.rs
@@ -275,7 +275,7 @@ pub async fn with_inherited_origin<F: std::future::Future>(
/// scoped **right now** into a future that will run on another task.
///
/// A `tokio::task_local` does not cross `tokio::spawn`: a detached sub-agent
-/// (`spawn_async_subagent`, the orchestration `spawn_agent` task) starts on a
+/// (`spawn_subagent`, the orchestration `spawn_agent` task) starts on a
/// fresh task where [`current`] is `None`, so every external-effect tool it
/// calls reaches the approval gate as [`AgentTurnOrigin::Unknown`] and is
/// refused — even though the parent turn that delegated the work was properly
diff --git a/crates/openhuman-core/src/security/turn_origin_tests.rs b/crates/openhuman-core/src/security/turn_origin_tests.rs
index dae8a7724f..c4ec0b44ee 100644
--- a/crates/openhuman-core/src/security/turn_origin_tests.rs
+++ b/crates/openhuman-core/src/security/turn_origin_tests.rs
@@ -97,7 +97,7 @@ async fn inherited_origin_preserves_a_non_cli_origin_verbatim() {
}
}
-/// Regression: a detached sub-agent (`spawn_async_subagent`, the
+/// Regression: a detached sub-agent (`spawn_subagent`, the
/// orchestration spawn task) starts on a fresh task, and without explicit
/// propagation its tools reach the approval gate as `Unknown` and every
/// external-effect call is refused — the parent's label silently lost at
diff --git a/crates/openhuman-core/src/threads/turn_state/mirror/observe.rs b/crates/openhuman-core/src/threads/turn_state/mirror/observe.rs
index d49d66a3ed..d1f0eaea3f 100644
--- a/crates/openhuman-core/src/threads/turn_state/mirror/observe.rs
+++ b/crates/openhuman-core/src/threads/turn_state/mirror/observe.rs
@@ -150,7 +150,7 @@ impl ObserveProgress for TurnStateMirror {
self.state.phase = Some(TurnPhase::Subagent);
self.state.active_subagent = Some(agent_id.clone());
// Derive the real invoking tool's name from the parent row
- // (`spawn_async_subagent`,
+ // (`spawn_subagent`,
// `continue_subagent`, a synthesized `delegate_*`, …) instead
// of hardcoding `spawn_subagent`, which was wrong for every
// other delegation path. Falls back to the historical
diff --git a/crates/openhuman-core/src/threads/turn_state/mirror_observe_tests.rs b/crates/openhuman-core/src/threads/turn_state/mirror_observe_tests.rs
index 71a16fa710..8936fd068e 100644
--- a/crates/openhuman-core/src/threads/turn_state/mirror_observe_tests.rs
+++ b/crates/openhuman-core/src/threads/turn_state/mirror_observe_tests.rs
@@ -626,7 +626,7 @@ fn thinking_timing_wire_shape_is_camel_case_and_backward_compatible() {
#[test]
fn subagent_spawned_derives_source_tool_name_from_the_parent_row() {
// Only `spawn_subagent` ever hardcoded a "spawn_subagent" source. Every
- // other delegation path (`spawn_async_subagent`,
+ // other delegation path (`spawn_subagent`,
// a synthesized `delegate_researcher`, …) must show its own real tool
// name, derived from the parent call's row by `parent_call_id` — never
// the historical hardcoded default.
diff --git a/crates/openhuman-core/src/tools/ops_tests_default_registry_tests.rs b/crates/openhuman-core/src/tools/ops_tests_default_registry_tests.rs
index 722f84cba2..bbe4ab66e6 100644
--- a/crates/openhuman-core/src/tools/ops_tests_default_registry_tests.rs
+++ b/crates/openhuman-core/src/tools/ops_tests_default_registry_tests.rs
@@ -409,7 +409,7 @@ fn all_tools_default_registry_contains_expected_baseline_surface() {
"apply_patch",
"csv_export",
"spawn_subagent",
- "spawn_async_subagent",
+ "spawn_subagent",
"ask_user_clarification",
"read_workspace_state",
"todo",
diff --git a/crates/openhuman-core/src/tools/toolpacks/registry.rs b/crates/openhuman-core/src/tools/toolpacks/registry.rs
index cc3746d39b..fa9f3eb876 100644
--- a/crates/openhuman-core/src/tools/toolpacks/registry.rs
+++ b/crates/openhuman-core/src/tools/toolpacks/registry.rs
@@ -58,7 +58,7 @@ pub const PACKS: &[ToolPack] = &[
"list_connectable_toolkits",
],
// The orchestrator is NOT an owner: it builds and discovers through
- // `spawn_async_subagent` (prompt.md) and reaches the rest via `use_skill`,
+ // `spawn_subagent` (prompt.md) and reaches the rest via `use_skill`,
// so owning the pack put all of it on its wire for nothing.
owners: &["workflow_builder", "flow_discovery"],
guide: "",
diff --git a/crates/openhuman-core/src/voice/realtime_harness/chat_delivery.rs b/crates/openhuman-core/src/voice/realtime_harness/chat_delivery.rs
index 69954b3c8e..f026056a87 100644
--- a/crates/openhuman-core/src/voice/realtime_harness/chat_delivery.rs
+++ b/crates/openhuman-core/src/voice/realtime_harness/chat_delivery.rs
@@ -24,7 +24,7 @@ use crate::platform::socket::manager::global_socket_manager;
/// - external_effect tool approvals raised on the `ExternalChannel` turn now
/// have a thread card to route to (the same `proactive:voice` thread where
/// deferred voice answers land) rather than silently TTL-denying.
-/// - The explicit run context gives async delegation (`spawn_async_subagent`) the
+/// - The explicit run context gives async delegation (`spawn_subagent`) the
/// `parent_thread_id` it requires and aligns inference logs / KV-cache with
/// the voice thread.
pub(super) const VOICE_CHAT_THREAD_ID: &str = "proactive:voice";
diff --git a/crates/openhuman-core/src/web_chat/ops/channel_ops.rs b/crates/openhuman-core/src/web_chat/ops/channel_ops.rs
index e09f7a45f0..12748bec91 100644
--- a/crates/openhuman-core/src/web_chat/ops/channel_ops.rs
+++ b/crates/openhuman-core/src/web_chat/ops/channel_ops.rs
@@ -137,7 +137,7 @@ async fn cancel_chat_inner(
});
// An unscoped stop also halts the thread's detached work. Async sub-agents
- // (`spawn_async_subagent`) run on their own tasks and deliberately drop the
+ // (`spawn_subagent`) run on their own tasks and deliberately drop the
// spawning turn's cancellation, so tearing the turn down leaves them
// running — and when one finishes, background delivery starts a fresh
// system turn on the thread, which reads as "Stop did nothing". Abort them
diff --git a/scripts/ci/agent-runtime-boundary-baseline.json b/scripts/ci/agent-runtime-boundary-baseline.json
index e8a596b7c2..b32dd15358 100644
--- a/scripts/ci/agent-runtime-boundary-baseline.json
+++ b/scripts/ci/agent-runtime-boundary-baseline.json
@@ -15,7 +15,7 @@
},
{
"rule": "openhuman-task-local",
- "path": "crates/openhuman-core/src/agent/orchestration/tools/spawn_async_subagent_execute.rs",
+ "path": "crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_execute.rs",
"line": 396,
"text": "let join = dispatch.spawn(crate::agent::turn_origin::propagate(",
"occurrence": 1
diff --git a/scripts/prompt-eval/cases.json b/scripts/prompt-eval/cases.json
index 10e8491c19..0d9eecd711 100644
--- a/scripts/prompt-eval/cases.json
+++ b/scripts/prompt-eval/cases.json
@@ -20,7 +20,7 @@
"web_search_tool"
],
"forbid_calls": [
- "spawn_async_subagent"
+ "spawn_subagent"
],
"max_consecutive": {
"web_search_tool": 3
@@ -59,7 +59,7 @@
"message": "What is 17 times 23?",
"expect_calls": [],
"forbid_calls": [
- "spawn_async_subagent",
+ "spawn_subagent",
"use_skill",
"cron"
],
@@ -82,7 +82,7 @@
"forbid_calls": [
"request_plan_review",
"todo",
- "spawn_async_subagent"
+ "spawn_subagent"
],
"max_consecutive": {
"web_search_tool": 4
diff --git a/tests/agent_harness_e2e.rs b/tests/agent_harness_e2e.rs
index 2542df45a2..89e16385f3 100644
--- a/tests/agent_harness_e2e.rs
+++ b/tests/agent_harness_e2e.rs
@@ -2042,14 +2042,14 @@ async fn provider_error_retry_inner() {
// request[2] = vision_agent (inner loop continuation) → DEPTH2_CANARY text
// request[3] = orchestrator synthesis
-/// Two `spawn_async_subagent` calls issued together really do put two workers
+/// Two `spawn_subagent` calls issued together really do put two workers
/// in flight: both are dispatched and both run, concurrently.
///
/// Concurrent async delegation calls keep independent workers in flight at
/// the same time.
///
/// The *other* half — both results reaching the user — is deliberately not
-/// asserted here, and not because it stopped mattering. `spawn_async_subagent`
+/// asserted here, and not because it stopped mattering. `spawn_subagent`
/// returns a task id immediately and results come back through
/// `orchestration::background_delivery`, which is documented "idle-gated —
/// never mid-turn" and debounced, i.e. on a LATER system turn. That subsystem
@@ -2087,11 +2087,11 @@ async fn concurrent_async_subagents_overlap_inner() {
reset_script(vec![
tool_calls_completion(&[
(
- "spawn_async_subagent",
+ "spawn_subagent",
json!({ "agent_id": "vision_agent", "prompt": "Find PARALLEL_ALPHA_CANARY" }),
),
(
- "spawn_async_subagent",
+ "spawn_subagent",
json!({ "agent_id": "vision_agent", "prompt": "Find PARALLEL_BETA_CANARY" }),
),
]),
@@ -4925,7 +4925,7 @@ async fn thread_goal_is_set_read_back_and_completed_across_turns_inner() {
/// Cancel aborts the detached task, and an aborted future never reaches its own
/// `Cancelled` branch — so before `AbortReport` the client got no terminal event
/// and the delegation card spun forever. This drives the production path: a
-/// real `spawn_async_subagent` child held mid-model-call by the canary barrier,
+/// real `spawn_subagent` child held mid-model-call by the canary barrier,
/// cancelled over the `openhuman.subagent_cancel` JSON-RPC, and observed on the
/// same SSE stream the app renders from (`subagent_failed` is what settles the
/// card's row). A second cancel then gets the RPC's "nothing running" answer
@@ -4946,7 +4946,7 @@ async fn cancelling_a_running_background_subagent_settles_it_inner() {
arm_canary_barrier(&["CANCEL_E2E_CANARY", "CANCEL_E2E_NEVER"]);
reset_script(vec![
tool_calls_completion(&[(
- "spawn_async_subagent",
+ "spawn_subagent",
json!({ "agent_id": "vision_agent", "prompt": "Find CANCEL_E2E_CANARY" }),
)]),
text_completion("Spawned a worker; its result will arrive later."),
diff --git a/tests/in_process/orchestrator_parallel_fanout_routing.rs b/tests/in_process/orchestrator_parallel_fanout_routing.rs
index 75e1e23c06..6d5c02bfca 100644
--- a/tests/in_process/orchestrator_parallel_fanout_routing.rs
+++ b/tests/in_process/orchestrator_parallel_fanout_routing.rs
@@ -11,7 +11,7 @@
//! #5757 (`02d81f6cf`) retired `spawn_parallel_agents` along with five other
//! sub-agent tools, cutting the surface from 11 tools to 3. A dedicated fan-out
//! tool was judged "a second way to say spawn again" now that
-//! `spawn_async_subagent` is always async: it returns a task id immediately, so
+//! `spawn_subagent` is always async: it returns a task id immediately, so
//! N spawns issued together are already N workers running concurrently. The
//! retirement is pinned both ways in `agents/loader.rs` — three tools required,
//! six asserted absent — so it is deliberate and enforced, not drift.
@@ -29,12 +29,12 @@ fn prompt_routes_fanout_to_concurrent_async_spawns() {
let prompt = ORCHESTRATOR_PROMPT.to_lowercase();
// The fan-out guidance must exist and name the primitive that actually
- // runs concurrently. Post-#5757 that is `spawn_async_subagent`; the
+ // runs concurrently. Post-#5757 that is `spawn_subagent`; the
// assertion is deliberately on the *current* tool rather than on whichever
// name happened to be right in 2026, because a prompt naming a retired
// tool is the failure this file is meant to catch.
assert!(
- ORCHESTRATOR_PROMPT.contains("spawn_async_subagent"),
+ ORCHESTRATOR_PROMPT.contains("spawn_subagent"),
"orchestrator prompt must name the concurrent spawn primitive (#4754, #5757)"
);
@@ -91,7 +91,7 @@ fn prompt_does_not_teach_a_retired_subagent_tool() {
// re-anchor it to. `spawn_subagent` survives in exactly one agent —
// `trigger_reactor/agent.toml` — and that agent's tool list is
// `spawn_subagent` alone: no `spawn_parallel_agents`, and no
-// `spawn_async_subagent` either. So the redirect is dangling for its only
+// `spawn_subagent` either. So the redirect is dangling for its only
// caller, and pointing it at the new tool would leave it just as dangling.
//
// The underlying defect is in `src/`, not in a test: `spawn_subagent`'s
diff --git a/tests/saas_mode/delivery_recovery.rs b/tests/saas_mode/delivery_recovery.rs
index 027cc75868..b47f566d2b 100644
--- a/tests/saas_mode/delivery_recovery.rs
+++ b/tests/saas_mode/delivery_recovery.rs
@@ -5,7 +5,7 @@
//! sub-agent finishing and its result being delivered: a pending record in
//! the profile's completion queue (the `orchestration_completions` documents
//! of its scope in `<workspace>/storage`), addressed by thread id. The SaaS user
-//! surface does not offer `spawn_async_subagent` (the `agent` domain is off
+//! surface does not offer `spawn_subagent` (the `agent` domain is off
//! for profiles), so the record is written here, through the harness's own
//! store, while the core is down, exactly as `record_completion` would have
//! written it.