diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts
index d7a5e7395..71dda755d 100644
--- a/packages/cli/src/acp-integration/session/Session.ts
+++ b/packages/cli/src/acp-integration/session/Session.ts
@@ -16,7 +16,7 @@ import type {
   ToolCallConfirmationDetails,
   ToolResult,
   ChatRecord,
-  SubAgentEventEmitter,
+  AgentEventEmitter,
 } from '@qwen-code/qwen-code-core';
 import {
   AuthType,
@@ -488,7 +488,7 @@ export class Session implements SessionContext {
         // Access eventEmitter from TaskTool invocation
         const taskEventEmitter = (
           invocation as {
-            eventEmitter: SubAgentEventEmitter;
+            eventEmitter: AgentEventEmitter;
           }
         ).eventEmitter;
 
@@ -497,7 +497,7 @@ export class Session implements SessionContext {
         const subagentType = (args['subagent_type'] as string) ?? '';
 
         // Create a SubAgentTracker for this tool execution
-        const subAgentTracker = new SubAgentTracker(
+        const subSubAgentTracker = new SubAgentTracker(
           this,
           this.client,
           parentToolCallId,
@@ -505,7 +505,7 @@ export class Session implements SessionContext {
         );
 
         // Set up sub-agent tool tracking
-        subAgentCleanupFunctions = subAgentTracker.setup(
+        subAgentCleanupFunctions = subSubAgentTracker.setup(
           taskEventEmitter,
           abortSignal,
         );
diff --git a/packages/cli/src/acp-integration/session/SubAgentTracker.test.ts b/packages/cli/src/acp-integration/session/SubAgentTracker.test.ts
index 96b8bd998..472a7b9ef 100644
--- a/packages/cli/src/acp-integration/session/SubAgentTracker.test.ts
+++ b/packages/cli/src/acp-integration/session/SubAgentTracker.test.ts
@@ -10,26 +10,26 @@ import type { SessionContext } from './types.js';
 import type {
   Config,
   ToolRegistry,
-  SubAgentEventEmitter,
-  SubAgentToolCallEvent,
-  SubAgentToolResultEvent,
-  SubAgentApprovalRequestEvent,
-  SubAgentStreamTextEvent,
+  AgentEventEmitter,
+  AgentToolCallEvent,
+  AgentToolResultEvent,
+  AgentApprovalRequestEvent,
+  AgentStreamTextEvent,
   ToolEditConfirmationDetails,
   ToolInfoConfirmationDetails,
 } from '@qwen-code/qwen-code-core';
 import {
-  SubAgentEventType,
+  AgentEventType,
   ToolConfirmationOutcome,
   TodoWriteTool,
 } from '@qwen-code/qwen-code-core';
 import type * as acp from '../acp.js';
 import { EventEmitter } from 'node:events';
 
-// Helper to create a mock SubAgentToolCallEvent with required fields
+// Helper to create a mock AgentToolCallEvent with required fields
 function createToolCallEvent(
-  overrides: Partial<SubAgentToolCallEvent> & { name: string; callId: string },
-): SubAgentToolCallEvent {
+  overrides: Partial<AgentToolCallEvent> & { name: string; callId: string },
+): AgentToolCallEvent {
   return {
     subagentId: 'test-subagent',
     round: 1,
@@ -40,14 +40,14 @@ function createToolCallEvent(
   };
 }
 
-// Helper to create a mock SubAgentToolResultEvent with required fields
+// Helper to create a mock AgentToolResultEvent with required fields
 function createToolResultEvent(
-  overrides: Partial<SubAgentToolResultEvent> & {
+  overrides: Partial<AgentToolResultEvent> & {
     name: string;
     callId: string;
     success: boolean;
   },
-): SubAgentToolResultEvent {
+): AgentToolResultEvent {
   return {
     subagentId: 'test-subagent',
     round: 1,
@@ -56,15 +56,15 @@ function createToolResultEvent(
   };
 }
 
-// Helper to create a mock SubAgentApprovalRequestEvent with required fields
+// Helper to create a mock AgentApprovalRequestEvent with required fields
 function createApprovalEvent(
-  overrides: Partial<SubAgentApprovalRequestEvent> & {
+  overrides: Partial<AgentApprovalRequestEvent> & {
     name: string;
     callId: string;
-    confirmationDetails: SubAgentApprovalRequestEvent['confirmationDetails'];
-    respond: SubAgentApprovalRequestEvent['respond'];
+    confirmationDetails: AgentApprovalRequestEvent['confirmationDetails'];
+    respond: AgentApprovalRequestEvent['respond'];
   },
-): SubAgentApprovalRequestEvent {
+): AgentApprovalRequestEvent {
   return {
     subagentId: 'test-subagent',
     round: 1,
@@ -102,10 +102,10 @@ function createInfoConfirmation(
   };
 }
 
-// Helper to create a mock SubAgentStreamTextEvent with required fields
+// Helper to create a mock AgentStreamTextEvent with required fields
 function createStreamTextEvent(
-  overrides: Partial<SubAgentStreamTextEvent> & { text: string },
-): SubAgentStreamTextEvent {
+  overrides: Partial<AgentStreamTextEvent> & { text: string },
+): AgentStreamTextEvent {
   return {
     subagentId: 'test-subagent',
     round: 1,
@@ -120,7 +120,7 @@ describe('SubAgentTracker', () => {
   let sendUpdateSpy: ReturnType<typeof vi.fn>;
   let requestPermissionSpy: ReturnType<typeof vi.fn>;
   let tracker: SubAgentTracker;
-  let eventEmitter: SubAgentEventEmitter;
+  let eventEmitter: AgentEventEmitter;
   let abortController: AbortController;
 
   beforeEach(() => {
@@ -151,7 +151,7 @@ describe('SubAgentTracker', () => {
       'parent-call-123',
       'test-subagent',
     );
-    eventEmitter = new EventEmitter() as unknown as SubAgentEventEmitter;
+    eventEmitter = new EventEmitter() as unknown as AgentEventEmitter;
     abortController = new AbortController();
   });
 
@@ -169,19 +169,19 @@ describe('SubAgentTracker', () => {
       tracker.setup(eventEmitter, abortController.signal);
 
       expect(onSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_CALL,
+        AgentEventType.TOOL_CALL,
         expect.any(Function),
       );
       expect(onSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_RESULT,
+        AgentEventType.TOOL_RESULT,
         expect.any(Function),
       );
       expect(onSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_WAITING_APPROVAL,
+        AgentEventType.TOOL_WAITING_APPROVAL,
         expect.any(Function),
       );
       expect(onSpy).toHaveBeenCalledWith(
-        SubAgentEventType.STREAM_TEXT,
+        AgentEventType.STREAM_TEXT,
         expect.any(Function),
       );
     });
@@ -193,19 +193,19 @@ describe('SubAgentTracker', () => {
       cleanups[0]();
 
       expect(offSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_CALL,
+        AgentEventType.TOOL_CALL,
         expect.any(Function),
       );
       expect(offSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_RESULT,
+        AgentEventType.TOOL_RESULT,
         expect.any(Function),
       );
       expect(offSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_WAITING_APPROVAL,
+        AgentEventType.TOOL_WAITING_APPROVAL,
         expect.any(Function),
       );
       expect(offSpy).toHaveBeenCalledWith(
-        SubAgentEventType.STREAM_TEXT,
+        AgentEventType.STREAM_TEXT,
         expect.any(Function),
       );
     });
@@ -222,7 +222,7 @@ describe('SubAgentTracker', () => {
         description: 'Reading file',
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_CALL, event);
+      eventEmitter.emit(AgentEventType.TOOL_CALL, event);
 
       // Allow async operations to complete
       await vi.waitFor(() => {
@@ -258,7 +258,7 @@ describe('SubAgentTracker', () => {
         args: { todos: [] },
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_CALL, event);
+      eventEmitter.emit(AgentEventType.TOOL_CALL, event);
 
       // Give time for any async operation
       await new Promise((resolve) => setTimeout(resolve, 10));
@@ -276,7 +276,7 @@ describe('SubAgentTracker', () => {
         args: {},
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_CALL, event);
+      eventEmitter.emit(AgentEventType.TOOL_CALL, event);
 
       await new Promise((resolve) => setTimeout(resolve, 10));
 
@@ -290,7 +290,7 @@ describe('SubAgentTracker', () => {
 
       // First emit tool call to store state
       eventEmitter.emit(
-        SubAgentEventType.TOOL_CALL,
+        AgentEventType.TOOL_CALL,
         createToolCallEvent({
           name: 'read_file',
           callId: 'call-123',
@@ -306,7 +306,7 @@ describe('SubAgentTracker', () => {
         resultDisplay: 'File contents',
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_RESULT, resultEvent);
+      eventEmitter.emit(AgentEventType.TOOL_RESULT, resultEvent);
 
       await vi.waitFor(() => {
         expect(sendUpdateSpy).toHaveBeenCalledWith(
@@ -334,7 +334,7 @@ describe('SubAgentTracker', () => {
         resultDisplay: undefined,
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_RESULT, resultEvent);
+      eventEmitter.emit(AgentEventType.TOOL_RESULT, resultEvent);
 
       await vi.waitFor(() => {
         expect(sendUpdateSpy).toHaveBeenCalledWith(
@@ -356,7 +356,7 @@ describe('SubAgentTracker', () => {
 
       // Store args via tool call
       eventEmitter.emit(
-        SubAgentEventType.TOOL_CALL,
+        AgentEventType.TOOL_CALL,
         createToolCallEvent({
           name: TodoWriteTool.Name,
           callId: 'call-todo',
@@ -377,7 +377,7 @@ describe('SubAgentTracker', () => {
         }),
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_RESULT, resultEvent);
+      eventEmitter.emit(AgentEventType.TOOL_RESULT, resultEvent);
 
       await vi.waitFor(() => {
         expect(sendUpdateSpy).toHaveBeenCalledWith({
@@ -393,7 +393,7 @@ describe('SubAgentTracker', () => {
       tracker.setup(eventEmitter, abortController.signal);
 
       eventEmitter.emit(
-        SubAgentEventType.TOOL_CALL,
+        AgentEventType.TOOL_CALL,
         createToolCallEvent({
           name: 'test_tool',
           callId: 'call-cleanup',
@@ -402,7 +402,7 @@ describe('SubAgentTracker', () => {
       );
 
       eventEmitter.emit(
-        SubAgentEventType.TOOL_RESULT,
+        AgentEventType.TOOL_RESULT,
         createToolResultEvent({
           name: 'test_tool',
           callId: 'call-cleanup',
@@ -413,7 +413,7 @@ describe('SubAgentTracker', () => {
       // Emit another result for same callId - should not have stored args
       sendUpdateSpy.mockClear();
       eventEmitter.emit(
-        SubAgentEventType.TOOL_RESULT,
+        AgentEventType.TOOL_RESULT,
         createToolResultEvent({
           name: 'test_tool',
           callId: 'call-cleanup',
@@ -447,7 +447,7 @@ describe('SubAgentTracker', () => {
         respond: respondSpy,
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+      eventEmitter.emit(AgentEventType.TOOL_WAITING_APPROVAL, event);
 
       await vi.waitFor(() => {
         expect(requestPermissionSpy).toHaveBeenCalled();
@@ -483,7 +483,7 @@ describe('SubAgentTracker', () => {
         respond: respondSpy,
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+      eventEmitter.emit(AgentEventType.TOOL_WAITING_APPROVAL, event);
 
       await vi.waitFor(() => {
         expect(respondSpy).toHaveBeenCalledWith(
@@ -504,7 +504,7 @@ describe('SubAgentTracker', () => {
         respond: respondSpy,
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+      eventEmitter.emit(AgentEventType.TOOL_WAITING_APPROVAL, event);
 
       await vi.waitFor(() => {
         expect(respondSpy).toHaveBeenCalledWith(ToolConfirmationOutcome.Cancel);
@@ -525,7 +525,7 @@ describe('SubAgentTracker', () => {
         respond: respondSpy,
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+      eventEmitter.emit(AgentEventType.TOOL_WAITING_APPROVAL, event);
 
       await vi.waitFor(() => {
         expect(respondSpy).toHaveBeenCalledWith(ToolConfirmationOutcome.Cancel);
@@ -548,7 +548,7 @@ describe('SubAgentTracker', () => {
         respond: vi.fn(),
       });
 
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+      eventEmitter.emit(AgentEventType.TOOL_WAITING_APPROVAL, event);
 
       await vi.waitFor(() => {
         expect(requestPermissionSpy).toHaveBeenCalled();
@@ -572,7 +572,7 @@ describe('SubAgentTracker', () => {
         text: 'Hello, this is a response from the model.',
       });
 
-      eventEmitter.emit(SubAgentEventType.STREAM_TEXT, event);
+      eventEmitter.emit(AgentEventType.STREAM_TEXT, event);
 
       await vi.waitFor(() => {
         expect(sendUpdateSpy).toHaveBeenCalled();
@@ -593,15 +593,15 @@ describe('SubAgentTracker', () => {
       tracker.setup(eventEmitter, abortController.signal);
 
       eventEmitter.emit(
-        SubAgentEventType.STREAM_TEXT,
+        AgentEventType.STREAM_TEXT,
         createStreamTextEvent({ text: 'First chunk ' }),
       );
       eventEmitter.emit(
-        SubAgentEventType.STREAM_TEXT,
+        AgentEventType.STREAM_TEXT,
         createStreamTextEvent({ text: 'Second chunk ' }),
       );
       eventEmitter.emit(
-        SubAgentEventType.STREAM_TEXT,
+        AgentEventType.STREAM_TEXT,
         createStreamTextEvent({ text: 'Third chunk' }),
       );
 
@@ -640,7 +640,7 @@ describe('SubAgentTracker', () => {
         text: 'This should not be emitted',
       });
 
-      eventEmitter.emit(SubAgentEventType.STREAM_TEXT, event);
+      eventEmitter.emit(AgentEventType.STREAM_TEXT, event);
 
       await new Promise((resolve) => setTimeout(resolve, 10));
 
@@ -655,7 +655,7 @@ describe('SubAgentTracker', () => {
         thought: true,
       });
 
-      eventEmitter.emit(SubAgentEventType.STREAM_TEXT, event);
+      eventEmitter.emit(AgentEventType.STREAM_TEXT, event);
 
       await vi.waitFor(() => {
         expect(sendUpdateSpy).toHaveBeenCalled();
@@ -680,7 +680,7 @@ describe('SubAgentTracker', () => {
         thought: false,
       });
 
-      eventEmitter.emit(SubAgentEventType.STREAM_TEXT, event);
+      eventEmitter.emit(AgentEventType.STREAM_TEXT, event);
 
       await vi.waitFor(() => {
         expect(sendUpdateSpy).toHaveBeenCalled();
@@ -705,7 +705,7 @@ describe('SubAgentTracker', () => {
         text: 'Default behavior text.',
       });
 
-      eventEmitter.emit(SubAgentEventType.STREAM_TEXT, event);
+      eventEmitter.emit(AgentEventType.STREAM_TEXT, event);
 
       await vi.waitFor(() => {
         expect(sendUpdateSpy).toHaveBeenCalled();
diff --git a/packages/cli/src/acp-integration/session/SubAgentTracker.ts b/packages/cli/src/acp-integration/session/SubAgentTracker.ts
index d020f2a06..9f56de198 100644
--- a/packages/cli/src/acp-integration/session/SubAgentTracker.ts
+++ b/packages/cli/src/acp-integration/session/SubAgentTracker.ts
@@ -5,18 +5,18 @@
  */
 
 import type {
-  SubAgentEventEmitter,
-  SubAgentToolCallEvent,
-  SubAgentToolResultEvent,
-  SubAgentApprovalRequestEvent,
-  SubAgentUsageEvent,
-  SubAgentStreamTextEvent,
+  AgentEventEmitter,
+  AgentToolCallEvent,
+  AgentToolResultEvent,
+  AgentApprovalRequestEvent,
+  AgentUsageEvent,
+  AgentStreamTextEvent,
   ToolCallConfirmationDetails,
   AnyDeclarativeTool,
   AnyToolInvocation,
 } from '@qwen-code/qwen-code-core';
 import {
-  SubAgentEventType,
+  AgentEventType,
   ToolConfirmationOutcome,
   createDebugLogger,
 } from '@qwen-code/qwen-code-core';
@@ -101,12 +101,12 @@ export class SubAgentTracker {
   /**
    * Sets up event listeners for a sub-agent's tool events.
    *
-   * @param eventEmitter - The SubAgentEventEmitter from TaskTool
+   * @param eventEmitter - The AgentEventEmitter from TaskTool
    * @param abortSignal - Signal to abort tracking if parent is cancelled
    * @returns Array of cleanup functions to remove listeners
    */
   setup(
-    eventEmitter: SubAgentEventEmitter,
+    eventEmitter: AgentEventEmitter,
     abortSignal: AbortSignal,
   ): Array<() => void> {
     const onToolCall = this.createToolCallHandler(abortSignal);
@@ -115,19 +115,19 @@ export class SubAgentTracker {
     const onUsageMetadata = this.createUsageMetadataHandler(abortSignal);
     const onStreamText = this.createStreamTextHandler(abortSignal);
 
-    eventEmitter.on(SubAgentEventType.TOOL_CALL, onToolCall);
-    eventEmitter.on(SubAgentEventType.TOOL_RESULT, onToolResult);
-    eventEmitter.on(SubAgentEventType.TOOL_WAITING_APPROVAL, onApproval);
-    eventEmitter.on(SubAgentEventType.USAGE_METADATA, onUsageMetadata);
-    eventEmitter.on(SubAgentEventType.STREAM_TEXT, onStreamText);
+    eventEmitter.on(AgentEventType.TOOL_CALL, onToolCall);
+    eventEmitter.on(AgentEventType.TOOL_RESULT, onToolResult);
+    eventEmitter.on(AgentEventType.TOOL_WAITING_APPROVAL, onApproval);
+    eventEmitter.on(AgentEventType.USAGE_METADATA, onUsageMetadata);
+    eventEmitter.on(AgentEventType.STREAM_TEXT, onStreamText);
 
     return [
       () => {
-        eventEmitter.off(SubAgentEventType.TOOL_CALL, onToolCall);
-        eventEmitter.off(SubAgentEventType.TOOL_RESULT, onToolResult);
-        eventEmitter.off(SubAgentEventType.TOOL_WAITING_APPROVAL, onApproval);
-        eventEmitter.off(SubAgentEventType.USAGE_METADATA, onUsageMetadata);
-        eventEmitter.off(SubAgentEventType.STREAM_TEXT, onStreamText);
+        eventEmitter.off(AgentEventType.TOOL_CALL, onToolCall);
+        eventEmitter.off(AgentEventType.TOOL_RESULT, onToolResult);
+        eventEmitter.off(AgentEventType.TOOL_WAITING_APPROVAL, onApproval);
+        eventEmitter.off(AgentEventType.USAGE_METADATA, onUsageMetadata);
+        eventEmitter.off(AgentEventType.STREAM_TEXT, onStreamText);
         // Clean up any remaining states
         this.toolStates.clear();
       },
@@ -141,7 +141,7 @@ export class SubAgentTracker {
     abortSignal: AbortSignal,
   ): (...args: unknown[]) => void {
     return (...args: unknown[]) => {
-      const event = args[0] as SubAgentToolCallEvent;
+      const event = args[0] as AgentToolCallEvent;
       if (abortSignal.aborted) return;
 
       // Look up tool and build invocation for metadata
@@ -182,7 +182,7 @@ export class SubAgentTracker {
     abortSignal: AbortSignal,
   ): (...args: unknown[]) => void {
     return (...args: unknown[]) => {
-      const event = args[0] as SubAgentToolResultEvent;
+      const event = args[0] as AgentToolResultEvent;
       if (abortSignal.aborted) return;
 
       const state = this.toolStates.get(event.callId);
@@ -210,7 +210,7 @@ export class SubAgentTracker {
     abortSignal: AbortSignal,
   ): (...args: unknown[]) => Promise<void> {
     return async (...args: unknown[]) => {
-      const event = args[0] as SubAgentApprovalRequestEvent;
+      const event = args[0] as AgentApprovalRequestEvent;
       if (abortSignal.aborted) return;
 
       const state = this.toolStates.get(event.callId);
@@ -287,7 +287,7 @@ export class SubAgentTracker {
     abortSignal: AbortSignal,
   ): (...args: unknown[]) => void {
     return (...args: unknown[]) => {
-      const event = args[0] as SubAgentUsageEvent;
+      const event = args[0] as AgentUsageEvent;
       if (abortSignal.aborted) return;
 
       this.messageEmitter.emitUsageMetadata(
@@ -307,7 +307,7 @@ export class SubAgentTracker {
     abortSignal: AbortSignal,
   ): (...args: unknown[]) => void {
     return (...args: unknown[]) => {
-      const event = args[0] as SubAgentStreamTextEvent;
+      const event = args[0] as AgentStreamTextEvent;
       if (abortSignal.aborted) return;
 
       // Emit streamed text as agent message or thought based on the flag
diff --git a/packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts b/packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
index a81520be3..d0f0e2c81 100644
--- a/packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
+++ b/packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
@@ -6,6 +6,7 @@
 
 import type { GenerateContentResponseUsageMetadata } from '@google/genai';
 import type { Usage } from '../../schema.js';
+import type { SubagentMeta } from '../types.js';
 import { BaseEmitter } from './BaseEmitter.js';
 
 /**
@@ -77,7 +78,7 @@ export class MessageEmitter extends BaseEmitter {
     usageMetadata: GenerateContentResponseUsageMetadata,
     text: string = '',
     durationMs?: number,
-    subagentMeta?: import('../types.js').SubagentMeta,
+    subagentMeta?: SubagentMeta,
   ): Promise<void> {
     const usage: Usage = {
       promptTokens: usageMetadata.promptTokenCount,
diff --git a/packages/cli/src/ui/AppContainer.test.tsx b/packages/cli/src/ui/AppContainer.test.tsx
index 1edec79f9..57eacc797 100644
--- a/packages/cli/src/ui/AppContainer.test.tsx
+++ b/packages/cli/src/ui/AppContainer.test.tsx
@@ -267,7 +267,7 @@ describe('AppContainer State Management', () => {
       listSubagents: vi.fn().mockResolvedValue([]),
       addChangeListener: vi.fn(),
       loadSubagent: vi.fn(),
-      createSubagentScope: vi.fn(),
+      createSubagent: vi.fn(),
     };
     vi.spyOn(mockConfig, 'getSubagentManager').mockReturnValue(
       mockSubagentManager as SubagentManager,
diff --git a/packages/cli/src/ui/components/subagents/runtime/AgentExecutionDisplay.tsx b/packages/cli/src/ui/components/subagents/runtime/AgentExecutionDisplay.tsx
index 8f9fe2a6a..8da7a3a24 100644
--- a/packages/cli/src/ui/components/subagents/runtime/AgentExecutionDisplay.tsx
+++ b/packages/cli/src/ui/components/subagents/runtime/AgentExecutionDisplay.tsx
@@ -8,7 +8,7 @@ import React, { useMemo } from 'react';
 import { Box, Text } from 'ink';
 import type {
   TaskResultDisplay,
-  SubagentStatsSummary,
+  AgentStatsSummary,
   Config,
 } from '@qwen-code/qwen-code-core';
 import { theme } from '../../../semantic-colors.js';
@@ -467,7 +467,7 @@ const ExecutionSummaryDetails: React.FC<{
  * Tool usage statistics component
  */
 const ToolUsageStats: React.FC<{
-  executionSummary?: SubagentStatsSummary;
+  executionSummary?: AgentStatsSummary;
 }> = ({ executionSummary }) => {
   if (!executionSummary) {
     return (
diff --git a/packages/core/src/agents-collab/arena/ArenaAgentClient.test.ts b/packages/core/src/agents/arena/ArenaAgentClient.test.ts
similarity index 100%
rename from packages/core/src/agents-collab/arena/ArenaAgentClient.test.ts
rename to packages/core/src/agents/arena/ArenaAgentClient.test.ts
diff --git a/packages/core/src/agents-collab/arena/ArenaAgentClient.ts b/packages/core/src/agents/arena/ArenaAgentClient.ts
similarity index 100%
rename from packages/core/src/agents-collab/arena/ArenaAgentClient.ts
rename to packages/core/src/agents/arena/ArenaAgentClient.ts
diff --git a/packages/core/src/agents-collab/arena/ArenaManager.test.ts b/packages/core/src/agents/arena/ArenaManager.test.ts
similarity index 100%
rename from packages/core/src/agents-collab/arena/ArenaManager.test.ts
rename to packages/core/src/agents/arena/ArenaManager.test.ts
diff --git a/packages/core/src/agents-collab/arena/ArenaManager.ts b/packages/core/src/agents/arena/ArenaManager.ts
similarity index 100%
rename from packages/core/src/agents-collab/arena/ArenaManager.ts
rename to packages/core/src/agents/arena/ArenaManager.ts
diff --git a/packages/core/src/agents-collab/arena/arena-events.ts b/packages/core/src/agents/arena/arena-events.ts
similarity index 100%
rename from packages/core/src/agents-collab/arena/arena-events.ts
rename to packages/core/src/agents/arena/arena-events.ts
diff --git a/packages/core/src/agents-collab/arena/index.ts b/packages/core/src/agents/arena/index.ts
similarity index 89%
rename from packages/core/src/agents-collab/arena/index.ts
rename to packages/core/src/agents/arena/index.ts
index 60d6b91e8..e744250c7 100644
--- a/packages/core/src/agents-collab/arena/index.ts
+++ b/packages/core/src/agents/arena/index.ts
@@ -11,4 +11,4 @@ export * from './ArenaManager.js';
 export * from './ArenaAgentClient.js';
 
 // Re-export shared agent infrastructure for backwards compatibility
-export * from '../index.js';
+export * from '../backends/index.js';
diff --git a/packages/core/src/agents-collab/arena/types.ts b/packages/core/src/agents/arena/types.ts
similarity index 100%
rename from packages/core/src/agents-collab/arena/types.ts
rename to packages/core/src/agents/arena/types.ts
diff --git a/packages/core/src/agents-collab/backends/ITermBackend.test.ts b/packages/core/src/agents/backends/ITermBackend.test.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/ITermBackend.test.ts
rename to packages/core/src/agents/backends/ITermBackend.test.ts
diff --git a/packages/core/src/agents-collab/backends/ITermBackend.ts b/packages/core/src/agents/backends/ITermBackend.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/ITermBackend.ts
rename to packages/core/src/agents/backends/ITermBackend.ts
diff --git a/packages/core/src/agents-collab/backends/TmuxBackend.test.ts b/packages/core/src/agents/backends/TmuxBackend.test.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/TmuxBackend.test.ts
rename to packages/core/src/agents/backends/TmuxBackend.test.ts
diff --git a/packages/core/src/agents-collab/backends/TmuxBackend.ts b/packages/core/src/agents/backends/TmuxBackend.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/TmuxBackend.ts
rename to packages/core/src/agents/backends/TmuxBackend.ts
diff --git a/packages/core/src/agents-collab/backends/detect.ts b/packages/core/src/agents/backends/detect.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/detect.ts
rename to packages/core/src/agents/backends/detect.ts
diff --git a/packages/core/src/agents-collab/backends/index.ts b/packages/core/src/agents/backends/index.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/index.ts
rename to packages/core/src/agents/backends/index.ts
diff --git a/packages/core/src/agents-collab/backends/iterm-it2.test.ts b/packages/core/src/agents/backends/iterm-it2.test.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/iterm-it2.test.ts
rename to packages/core/src/agents/backends/iterm-it2.test.ts
diff --git a/packages/core/src/agents-collab/backends/iterm-it2.ts b/packages/core/src/agents/backends/iterm-it2.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/iterm-it2.ts
rename to packages/core/src/agents/backends/iterm-it2.ts
diff --git a/packages/core/src/agents-collab/backends/tmux-commands.test.ts b/packages/core/src/agents/backends/tmux-commands.test.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/tmux-commands.test.ts
rename to packages/core/src/agents/backends/tmux-commands.test.ts
diff --git a/packages/core/src/agents-collab/backends/tmux-commands.ts b/packages/core/src/agents/backends/tmux-commands.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/tmux-commands.ts
rename to packages/core/src/agents/backends/tmux-commands.ts
diff --git a/packages/core/src/agents-collab/backends/types.ts b/packages/core/src/agents/backends/types.ts
similarity index 100%
rename from packages/core/src/agents-collab/backends/types.ts
rename to packages/core/src/agents/backends/types.ts
diff --git a/packages/core/src/agents-collab/index.ts b/packages/core/src/agents/index.ts
similarity index 92%
rename from packages/core/src/agents-collab/index.ts
rename to packages/core/src/agents/index.ts
index b811dbde3..d29d4dc09 100644
--- a/packages/core/src/agents-collab/index.ts
+++ b/packages/core/src/agents/index.ts
@@ -15,3 +15,4 @@
 
 export * from './backends/index.js';
 export * from './arena/index.js';
+export * from './runtime/index.js';
diff --git a/packages/core/src/agents/runtime/agent-core.ts b/packages/core/src/agents/runtime/agent-core.ts
new file mode 100644
index 000000000..8af0f9247
--- /dev/null
+++ b/packages/core/src/agents/runtime/agent-core.ts
@@ -0,0 +1,907 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview AgentCore — the shared execution engine for subagents.
+ *
+ * AgentCore encapsulates the model reasoning loop, tool scheduling, stats,
+ * and event emission. It is composed by both AgentHeadless (one-shot tasks)
+ * and AgentInteractive (persistent interactive agents).
+ *
+ * AgentCore is stateless per-call: it does not own lifecycle or termination
+ * logic. The caller (executor/collaborator) controls when to start, stop,
+ * and how to interpret the results.
+ */
+
+import { reportError } from '../../utils/errorReporting.js';
+import type { Config } from '../../config/config.js';
+import { type ToolCallRequestInfo } from '../../core/turn.js';
+import {
+  CoreToolScheduler,
+  type ToolCall,
+  type WaitingToolCall,
+} from '../../core/coreToolScheduler.js';
+import type {
+  ToolConfirmationOutcome,
+  ToolCallConfirmationDetails,
+} from '../../tools/tools.js';
+import { getInitialChatHistory } from '../../utils/environmentContext.js';
+import type {
+  Content,
+  Part,
+  FunctionCall,
+  GenerateContentConfig,
+  FunctionDeclaration,
+  GenerateContentResponseUsageMetadata,
+} from '@google/genai';
+import { GeminiChat } from '../../core/geminiChat.js';
+import type {
+  PromptConfig,
+  ModelConfig,
+  RunConfig,
+  ToolConfig,
+} from '../../subagents/types.js';
+import { SubagentTerminateMode } from '../../subagents/types.js';
+import type {
+  AgentRoundEvent,
+  AgentToolCallEvent,
+  AgentToolResultEvent,
+  AgentUsageEvent,
+} from './agent-events.js';
+import { type AgentEventEmitter, AgentEventType } from './agent-events.js';
+import { AgentStatistics, type AgentStatsSummary } from './agent-statistics.js';
+import type { AgentHooks } from './agent-hooks.js';
+import { TaskTool } from '../../tools/task.js';
+import { DEFAULT_QWEN_MODEL } from '../../config/models.js';
+import { type ContextState, templateString } from './agent-headless.js';
+
+/**
+ * Result of a single reasoning loop invocation.
+ */
+export interface ReasoningLoopResult {
+  /** The final model text response (empty if terminated by abort/limits). */
+  text: string;
+  /** Why the loop ended. null = normal text completion (no tool calls). */
+  terminateMode: SubagentTerminateMode | null;
+  /** Number of model round-trips completed. */
+  turnsUsed: number;
+}
+
+/**
+ * Options for configuring a reasoning loop invocation.
+ */
+export interface ReasoningLoopOptions {
+  /** Maximum number of turns before stopping. */
+  maxTurns?: number;
+  /** Maximum wall-clock time in minutes before stopping. */
+  maxTimeMinutes?: number;
+  /** Start time in ms (for timeout calculation). Defaults to Date.now(). */
+  startTimeMs?: number;
+}
+
+/**
+ * Options for chat creation.
+ */
+export interface CreateChatOptions {
+  /**
+   * When true, omits the "non-interactive mode" system prompt suffix.
+   * Used by AgentInteractive for persistent interactive agents.
+   */
+  interactive?: boolean;
+}
+
+/**
+ * Legacy execution stats maintained for backward compatibility.
+ */
+export interface ExecutionStats {
+  startTimeMs: number;
+  totalDurationMs: number;
+  rounds: number;
+  totalToolCalls: number;
+  successfulToolCalls: number;
+  failedToolCalls: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  estimatedCost?: number;
+}
+
+/**
+ * AgentCore — shared execution engine for model reasoning and tool scheduling.
+ *
+ * This class encapsulates:
+ * - Chat/model session creation (`createChat`)
+ * - Tool list preparation (`prepareTools`)
+ * - The inner reasoning loop (`runReasoningLoop`)
+ * - Tool call scheduling and execution (`processFunctionCalls`)
+ * - Statistics tracking and event emission
+ *
+ * It does NOT manage lifecycle (start/stop/terminate), abort signals,
+ * or final result interpretation — those are the caller's responsibility.
+ */
+export class AgentCore {
+  readonly subagentId: string;
+  readonly name: string;
+  readonly runtimeContext: Config;
+  readonly promptConfig: PromptConfig;
+  readonly modelConfig: ModelConfig;
+  readonly runConfig: RunConfig;
+  readonly toolConfig?: ToolConfig;
+  readonly eventEmitter?: AgentEventEmitter;
+  readonly hooks?: AgentHooks;
+  readonly stats = new AgentStatistics();
+
+  /**
+   * Legacy execution stats maintained for aggregate tracking.
+   */
+  executionStats: ExecutionStats = {
+    startTimeMs: 0,
+    totalDurationMs: 0,
+    rounds: 0,
+    totalToolCalls: 0,
+    successfulToolCalls: 0,
+    failedToolCalls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    estimatedCost: 0,
+  };
+  private toolUsage = new Map<
+    string,
+    {
+      count: number;
+      success: number;
+      failure: number;
+      lastError?: string;
+      totalDurationMs?: number;
+      averageDurationMs?: number;
+    }
+  >();
+
+  constructor(
+    name: string,
+    runtimeContext: Config,
+    promptConfig: PromptConfig,
+    modelConfig: ModelConfig,
+    runConfig: RunConfig,
+    toolConfig?: ToolConfig,
+    eventEmitter?: AgentEventEmitter,
+    hooks?: AgentHooks,
+  ) {
+    const randomPart = Math.random().toString(36).slice(2, 8);
+    this.subagentId = `${name}-${randomPart}`;
+    this.name = name;
+    this.runtimeContext = runtimeContext;
+    this.promptConfig = promptConfig;
+    this.modelConfig = modelConfig;
+    this.runConfig = runConfig;
+    this.toolConfig = toolConfig;
+    this.eventEmitter = eventEmitter;
+    this.hooks = hooks;
+  }
+
+  // ─── Chat Creation ────────────────────────────────────────
+
+  /**
+   * Creates a GeminiChat instance configured for this agent.
+   *
+   * @param context - Context state for template variable substitution.
+   * @param options - Chat creation options.
+   *   - `interactive`: When true, omits the "non-interactive mode" system prompt suffix.
+   * @returns A configured GeminiChat, or undefined if initialization fails.
+   */
+  async createChat(
+    context: ContextState,
+    options?: CreateChatOptions,
+  ): Promise<GeminiChat | undefined> {
+    if (!this.promptConfig.systemPrompt && !this.promptConfig.initialMessages) {
+      throw new Error(
+        'PromptConfig must have either `systemPrompt` or `initialMessages` defined.',
+      );
+    }
+    if (this.promptConfig.systemPrompt && this.promptConfig.initialMessages) {
+      throw new Error(
+        'PromptConfig cannot have both `systemPrompt` and `initialMessages` defined.',
+      );
+    }
+
+    const envHistory = await getInitialChatHistory(this.runtimeContext);
+
+    const startHistory = [
+      ...envHistory,
+      ...(this.promptConfig.initialMessages ?? []),
+    ];
+
+    const systemInstruction = this.promptConfig.systemPrompt
+      ? this.buildChatSystemPrompt(context, options)
+      : undefined;
+
+    try {
+      const generationConfig: GenerateContentConfig & {
+        systemInstruction?: string | Content;
+      } = {
+        temperature: this.modelConfig.temp,
+        topP: this.modelConfig.top_p,
+      };
+
+      if (systemInstruction) {
+        generationConfig.systemInstruction = systemInstruction;
+      }
+
+      return new GeminiChat(
+        this.runtimeContext,
+        generationConfig,
+        startHistory,
+      );
+    } catch (error) {
+      await reportError(
+        error,
+        'Error initializing chat session.',
+        startHistory,
+        'startChat',
+      );
+      return undefined;
+    }
+  }
+
+  // ─── Tool Preparation ─────────────────────────────────────
+
+  /**
+   * Prepares the list of tools available to this agent.
+   *
+   * If no explicit toolConfig or it contains "*" or is empty,
+   * inherits all tools (excluding TaskTool to prevent recursion).
+   */
+  prepareTools(): FunctionDeclaration[] {
+    const toolRegistry = this.runtimeContext.getToolRegistry();
+    const toolsList: FunctionDeclaration[] = [];
+
+    if (this.toolConfig) {
+      const asStrings = this.toolConfig.tools.filter(
+        (t): t is string => typeof t === 'string',
+      );
+      const hasWildcard = asStrings.includes('*');
+      const onlyInlineDecls = this.toolConfig.tools.filter(
+        (t): t is FunctionDeclaration => typeof t !== 'string',
+      );
+
+      if (hasWildcard || asStrings.length === 0) {
+        toolsList.push(
+          ...toolRegistry
+            .getFunctionDeclarations()
+            .filter((t) => t.name !== TaskTool.Name),
+        );
+      } else {
+        toolsList.push(
+          ...toolRegistry.getFunctionDeclarationsFiltered(asStrings),
+        );
+      }
+      toolsList.push(...onlyInlineDecls);
+    } else {
+      // Inherit all available tools by default when not specified.
+      toolsList.push(
+        ...toolRegistry
+          .getFunctionDeclarations()
+          .filter((t) => t.name !== TaskTool.Name),
+      );
+    }
+
+    return toolsList;
+  }
+
+  // ─── Reasoning Loop ───────────────────────────────────────
+
+  /**
+   * Runs the inner model reasoning loop.
+   *
+   * This is the core execution cycle:
+   * send messages → stream response → collect tool calls → execute tools → repeat.
+   *
+   * The loop terminates when:
+   * - The model produces a text response without tool calls (normal completion)
+   * - maxTurns is reached
+   * - maxTimeMinutes is exceeded
+   * - The abortController signal fires
+   *
+   * @param chat - The GeminiChat session to use.
+   * @param initialMessages - The first messages to send (e.g., user task prompt).
+   * @param toolsList - Available tool declarations.
+   * @param abortController - Controls cancellation of the current loop.
+   * @param options - Optional limits (maxTurns, maxTimeMinutes).
+   * @returns ReasoningLoopResult with the final text, terminate mode, and turns used.
+   */
+  async runReasoningLoop(
+    chat: GeminiChat,
+    initialMessages: Content[],
+    toolsList: FunctionDeclaration[],
+    abortController: AbortController,
+    options?: ReasoningLoopOptions,
+  ): Promise<ReasoningLoopResult> {
+    const startTime = options?.startTimeMs ?? Date.now();
+    let currentMessages = initialMessages;
+    let turnCounter = 0;
+    let finalText = '';
+    let terminateMode: SubagentTerminateMode | null = null;
+
+    while (true) {
+      // Check termination conditions.
+      if (options?.maxTurns && turnCounter >= options.maxTurns) {
+        terminateMode = SubagentTerminateMode.MAX_TURNS;
+        break;
+      }
+
+      let durationMin = (Date.now() - startTime) / (1000 * 60);
+      if (options?.maxTimeMinutes && durationMin >= options.maxTimeMinutes) {
+        terminateMode = SubagentTerminateMode.TIMEOUT;
+        break;
+      }
+
+      // Create a new AbortController per round to avoid listener accumulation
+      // in the model SDK. The parent abortController propagates abort to it.
+      const roundAbortController = new AbortController();
+      const onParentAbort = () => roundAbortController.abort();
+      abortController.signal.addEventListener('abort', onParentAbort);
+      if (abortController.signal.aborted) {
+        roundAbortController.abort();
+      }
+
+      const promptId = `${this.runtimeContext.getSessionId()}#${this.subagentId}#${turnCounter++}`;
+
+      const messageParams = {
+        message: currentMessages[0]?.parts || [],
+        config: {
+          abortSignal: roundAbortController.signal,
+          tools: [{ functionDeclarations: toolsList }],
+        },
+      };
+
+      const roundStreamStart = Date.now();
+      const responseStream = await chat.sendMessageStream(
+        this.modelConfig.model ||
+          this.runtimeContext.getModel() ||
+          DEFAULT_QWEN_MODEL,
+        messageParams,
+        promptId,
+      );
+      this.eventEmitter?.emit(AgentEventType.ROUND_START, {
+        subagentId: this.subagentId,
+        round: turnCounter,
+        promptId,
+        timestamp: Date.now(),
+      } as AgentRoundEvent);
+
+      const functionCalls: FunctionCall[] = [];
+      let roundText = '';
+      let lastUsage: GenerateContentResponseUsageMetadata | undefined =
+        undefined;
+      let currentResponseId: string | undefined = undefined;
+
+      for await (const streamEvent of responseStream) {
+        if (roundAbortController.signal.aborted) {
+          abortController.signal.removeEventListener('abort', onParentAbort);
+          return {
+            text: finalText,
+            terminateMode: SubagentTerminateMode.CANCELLED,
+            turnsUsed: turnCounter,
+          };
+        }
+
+        // Handle retry events
+        if (streamEvent.type === 'retry') {
+          continue;
+        }
+
+        // Handle chunk events
+        if (streamEvent.type === 'chunk') {
+          const resp = streamEvent.value;
+          // Track the response ID for tool call correlation
+          if (resp.responseId) {
+            currentResponseId = resp.responseId;
+          }
+          if (resp.functionCalls) functionCalls.push(...resp.functionCalls);
+          const content = resp.candidates?.[0]?.content;
+          const parts = content?.parts || [];
+          for (const p of parts) {
+            const txt = p.text;
+            const isThought = p.thought ?? false;
+            if (txt && !isThought) roundText += txt;
+            if (txt)
+              this.eventEmitter?.emit(AgentEventType.STREAM_TEXT, {
+                subagentId: this.subagentId,
+                round: turnCounter,
+                text: txt,
+                thought: isThought,
+                timestamp: Date.now(),
+              });
+          }
+          if (resp.usageMetadata) lastUsage = resp.usageMetadata;
+        }
+      }
+
+      this.executionStats.rounds = turnCounter;
+      this.stats.setRounds(turnCounter);
+
+      durationMin = (Date.now() - startTime) / (1000 * 60);
+      if (options?.maxTimeMinutes && durationMin >= options.maxTimeMinutes) {
+        abortController.signal.removeEventListener('abort', onParentAbort);
+        terminateMode = SubagentTerminateMode.TIMEOUT;
+        break;
+      }
+
+      // Update token usage if available
+      if (lastUsage) {
+        this.recordTokenUsage(lastUsage, turnCounter, roundStreamStart);
+      }
+
+      if (functionCalls.length > 0) {
+        currentMessages = await this.processFunctionCalls(
+          functionCalls,
+          roundAbortController,
+          promptId,
+          turnCounter,
+          toolsList,
+          currentResponseId,
+        );
+      } else {
+        // No tool calls — treat this as the model's final answer.
+        if (roundText && roundText.trim().length > 0) {
+          finalText = roundText.trim();
+          // Clean up before breaking
+          abortController.signal.removeEventListener('abort', onParentAbort);
+          // null terminateMode = normal text completion
+          break;
+        }
+        // Otherwise, nudge the model to finalize a result.
+        currentMessages = [
+          {
+            role: 'user',
+            parts: [
+              {
+                text: 'Please provide the final result now and stop calling tools.',
+              },
+            ],
+          },
+        ];
+      }
+
+      this.eventEmitter?.emit(AgentEventType.ROUND_END, {
+        subagentId: this.subagentId,
+        round: turnCounter,
+        promptId,
+        timestamp: Date.now(),
+      } as AgentRoundEvent);
+
+      // Clean up the per-round listener before the next iteration
+      abortController.signal.removeEventListener('abort', onParentAbort);
+    }
+
+    return {
+      text: finalText,
+      terminateMode,
+      turnsUsed: turnCounter,
+    };
+  }
+
+  // ─── Tool Execution ───────────────────────────────────────
+
+  /**
+   * Processes a list of function calls via CoreToolScheduler.
+   *
+   * Validates each call against the allowed tools list, schedules authorized
+   * calls, collects results, and emits events for each call/result.
+   *
+   * Validates each call, schedules authorized calls, collects results, and emits events.
+   */
+  async processFunctionCalls(
+    functionCalls: FunctionCall[],
+    abortController: AbortController,
+    promptId: string,
+    currentRound: number,
+    toolsList: FunctionDeclaration[],
+    responseId?: string,
+  ): Promise<Content[]> {
+    const toolResponseParts: Part[] = [];
+
+    // Build allowed tool names set for filtering
+    const allowedToolNames = new Set(toolsList.map((t) => t.name));
+
+    // Filter unauthorized tool calls before scheduling
+    const authorizedCalls: FunctionCall[] = [];
+    for (const fc of functionCalls) {
+      const callId = fc.id ?? `${fc.name}-${Date.now()}`;
+
+      if (!allowedToolNames.has(fc.name)) {
+        const toolName = String(fc.name);
+        const errorMessage = `Tool "${toolName}" not found. Tools must use the exact names provided.`;
+
+        // Emit TOOL_CALL event for visibility
+        this.eventEmitter?.emit(AgentEventType.TOOL_CALL, {
+          subagentId: this.subagentId,
+          round: currentRound,
+          callId,
+          name: toolName,
+          args: fc.args ?? {},
+          description: `Tool "${toolName}" not found`,
+          timestamp: Date.now(),
+        } as AgentToolCallEvent);
+
+        // Build function response part (used for both event and LLM)
+        const functionResponsePart = {
+          functionResponse: {
+            id: callId,
+            name: toolName,
+            response: { error: errorMessage },
+          },
+        };
+
+        // Emit TOOL_RESULT event with error
+        this.eventEmitter?.emit(AgentEventType.TOOL_RESULT, {
+          subagentId: this.subagentId,
+          round: currentRound,
+          callId,
+          name: toolName,
+          success: false,
+          error: errorMessage,
+          responseParts: [functionResponsePart],
+          resultDisplay: errorMessage,
+          durationMs: 0,
+          timestamp: Date.now(),
+        } as AgentToolResultEvent);
+
+        // Record blocked tool call in stats
+        this.recordToolCallStats(toolName, false, 0, errorMessage);
+
+        // Add function response for LLM
+        toolResponseParts.push(functionResponsePart);
+        continue;
+      }
+      authorizedCalls.push(fc);
+    }
+
+    // Build scheduler
+    const responded = new Set<string>();
+    let resolveBatch: (() => void) | null = null;
+    const scheduler = new CoreToolScheduler({
+      config: this.runtimeContext,
+      outputUpdateHandler: undefined,
+      onAllToolCallsComplete: async (completedCalls) => {
+        for (const call of completedCalls) {
+          const toolName = call.request.name;
+          const duration = call.durationMs ?? 0;
+          const success = call.status === 'success';
+          const errorMessage =
+            call.status === 'error' || call.status === 'cancelled'
+              ? call.response.error?.message
+              : undefined;
+
+          // Record stats
+          this.recordToolCallStats(toolName, success, duration, errorMessage);
+
+          // Emit tool result event
+          this.eventEmitter?.emit(AgentEventType.TOOL_RESULT, {
+            subagentId: this.subagentId,
+            round: currentRound,
+            callId: call.request.callId,
+            name: toolName,
+            success,
+            error: errorMessage,
+            responseParts: call.response.responseParts,
+            resultDisplay: call.response.resultDisplay
+              ? typeof call.response.resultDisplay === 'string'
+                ? call.response.resultDisplay
+                : JSON.stringify(call.response.resultDisplay)
+              : undefined,
+            durationMs: duration,
+            timestamp: Date.now(),
+          } as AgentToolResultEvent);
+
+          // post-tool hook
+          await this.hooks?.postToolUse?.({
+            subagentId: this.subagentId,
+            name: this.name,
+            toolName,
+            args: call.request.args,
+            success,
+            durationMs: duration,
+            errorMessage,
+            timestamp: Date.now(),
+          });
+
+          // Append response parts
+          const respParts = call.response.responseParts;
+          if (respParts) {
+            const parts = Array.isArray(respParts) ? respParts : [respParts];
+            for (const part of parts) {
+              if (typeof part === 'string') {
+                toolResponseParts.push({ text: part });
+              } else if (part) {
+                toolResponseParts.push(part);
+              }
+            }
+          }
+        }
+        // Signal that this batch is complete (all tools terminal)
+        resolveBatch?.();
+      },
+      onToolCallsUpdate: (calls: ToolCall[]) => {
+        for (const call of calls) {
+          if (call.status !== 'awaiting_approval') continue;
+          const waiting = call as WaitingToolCall;
+
+          // Emit approval request event for UI visibility
+          try {
+            const { confirmationDetails } = waiting;
+            const { onConfirm: _onConfirm, ...rest } = confirmationDetails;
+            this.eventEmitter?.emit(AgentEventType.TOOL_WAITING_APPROVAL, {
+              subagentId: this.subagentId,
+              round: currentRound,
+              callId: waiting.request.callId,
+              name: waiting.request.name,
+              description: this.getToolDescription(
+                waiting.request.name,
+                waiting.request.args,
+              ),
+              confirmationDetails: rest,
+              respond: async (
+                outcome: ToolConfirmationOutcome,
+                payload?: Parameters<
+                  ToolCallConfirmationDetails['onConfirm']
+                >[1],
+              ) => {
+                if (responded.has(waiting.request.callId)) return;
+                responded.add(waiting.request.callId);
+                await waiting.confirmationDetails.onConfirm(outcome, payload);
+              },
+              timestamp: Date.now(),
+            });
+          } catch {
+            // ignore UI event emission failures
+          }
+        }
+      },
+      getPreferredEditor: () => undefined,
+      onEditorClose: () => {},
+    });
+
+    // Prepare requests and emit TOOL_CALL events
+    const requests: ToolCallRequestInfo[] = authorizedCalls.map((fc) => {
+      const toolName = String(fc.name || 'unknown');
+      const callId = fc.id ?? `${fc.name}-${Date.now()}`;
+      const args = (fc.args ?? {}) as Record<string, unknown>;
+      const request: ToolCallRequestInfo = {
+        callId,
+        name: toolName,
+        args,
+        isClientInitiated: true,
+        prompt_id: promptId,
+        response_id: responseId,
+      };
+
+      const description = this.getToolDescription(toolName, args);
+      this.eventEmitter?.emit(AgentEventType.TOOL_CALL, {
+        subagentId: this.subagentId,
+        round: currentRound,
+        callId,
+        name: toolName,
+        args,
+        description,
+        timestamp: Date.now(),
+      } as AgentToolCallEvent);
+
+      // pre-tool hook
+      void this.hooks?.preToolUse?.({
+        subagentId: this.subagentId,
+        name: this.name,
+        toolName,
+        args,
+        timestamp: Date.now(),
+      });
+
+      return request;
+    });
+
+    if (requests.length > 0) {
+      // Create a per-batch completion promise
+      const batchDone = new Promise<void>((resolve) => {
+        resolveBatch = () => {
+          resolve();
+          resolveBatch = null;
+        };
+      });
+      await scheduler.schedule(requests, abortController.signal);
+      await batchDone;
+    }
+
+    // If all tool calls failed, inform the model so it can re-evaluate.
+    if (functionCalls.length > 0 && toolResponseParts.length === 0) {
+      toolResponseParts.push({
+        text: 'All tool calls failed. Please analyze the errors and try an alternative approach.',
+      });
+    }
+
+    return [{ role: 'user', parts: toolResponseParts }];
+  }
+
+  // ─── Stats & Events ───────────────────────────────────────
+
+  getEventEmitter(): AgentEventEmitter | undefined {
+    return this.eventEmitter;
+  }
+
+  getExecutionSummary(): AgentStatsSummary {
+    return this.stats.getSummary();
+  }
+
+  /**
+   * Returns legacy execution statistics and per-tool usage.
+   * Returns legacy execution statistics and per-tool usage.
+   */
+  getStatistics(): {
+    successRate: number;
+    toolUsage: Array<{
+      name: string;
+      count: number;
+      success: number;
+      failure: number;
+      lastError?: string;
+      totalDurationMs?: number;
+      averageDurationMs?: number;
+    }>;
+  } & ExecutionStats {
+    const total = this.executionStats.totalToolCalls;
+    const successRate =
+      total > 0 ? (this.executionStats.successfulToolCalls / total) * 100 : 0;
+    return {
+      ...this.executionStats,
+      successRate,
+      toolUsage: Array.from(this.toolUsage.entries()).map(([name, v]) => ({
+        name,
+        ...v,
+      })),
+    };
+  }
+
+  /**
+   * Safely retrieves the description of a tool by attempting to build it.
+   * Returns an empty string if any error occurs during the process.
+   */
+  getToolDescription(toolName: string, args: Record<string, unknown>): string {
+    try {
+      const toolRegistry = this.runtimeContext.getToolRegistry();
+      const tool = toolRegistry.getTool(toolName);
+      if (!tool) {
+        return '';
+      }
+
+      const toolInstance = tool.build(args);
+      return toolInstance.getDescription() || '';
+    } catch {
+      return '';
+    }
+  }
+
+  /**
+   * Records tool call statistics for both successful and failed tool calls.
+   */
+  recordToolCallStats(
+    toolName: string,
+    success: boolean,
+    durationMs: number,
+    errorMessage?: string,
+  ): void {
+    // Update aggregate stats
+    this.executionStats.totalToolCalls += 1;
+    if (success) {
+      this.executionStats.successfulToolCalls += 1;
+    } else {
+      this.executionStats.failedToolCalls += 1;
+    }
+
+    // Per-tool usage
+    const tu = this.toolUsage.get(toolName) || {
+      count: 0,
+      success: 0,
+      failure: 0,
+      totalDurationMs: 0,
+      averageDurationMs: 0,
+    };
+    tu.count += 1;
+    if (success) {
+      tu.success += 1;
+    } else {
+      tu.failure += 1;
+      tu.lastError = errorMessage || 'Unknown error';
+    }
+    tu.totalDurationMs = (tu.totalDurationMs || 0) + durationMs;
+    tu.averageDurationMs = tu.count > 0 ? tu.totalDurationMs / tu.count : 0;
+    this.toolUsage.set(toolName, tu);
+
+    // Update statistics service
+    this.stats.recordToolCall(
+      toolName,
+      success,
+      durationMs,
+      this.toolUsage.get(toolName)?.lastError,
+    );
+  }
+
+  // ─── Private Helpers ──────────────────────────────────────
+
+  /**
+   * Builds the system prompt with template substitution and optional
+   * non-interactive instructions suffix.
+   */
+  private buildChatSystemPrompt(
+    context: ContextState,
+    options?: CreateChatOptions,
+  ): string {
+    if (!this.promptConfig.systemPrompt) {
+      return '';
+    }
+
+    let finalPrompt = templateString(this.promptConfig.systemPrompt, context);
+
+    // Only add non-interactive instructions when NOT in interactive mode
+    if (!options?.interactive) {
+      finalPrompt += `
+
+Important Rules:
+ - You operate in non-interactive mode: do not ask the user questions; proceed with available context.
+ - Use tools only when necessary to obtain facts or make changes.
+ - When the task is complete, return the final result as a normal model response (not a tool call) and stop.`;
+    }
+
+    return finalPrompt;
+  }
+
+  /**
+   * Records token usage from model response metadata.
+   */
+  private recordTokenUsage(
+    usage: GenerateContentResponseUsageMetadata,
+    turnCounter: number,
+    roundStreamStart: number,
+  ): void {
+    const inTok = Number(usage.promptTokenCount || 0);
+    const outTok = Number(usage.candidatesTokenCount || 0);
+    const thoughtTok = Number(usage.thoughtsTokenCount || 0);
+    const cachedTok = Number(usage.cachedContentTokenCount || 0);
+    if (
+      isFinite(inTok) ||
+      isFinite(outTok) ||
+      isFinite(thoughtTok) ||
+      isFinite(cachedTok)
+    ) {
+      this.stats.recordTokens(
+        isFinite(inTok) ? inTok : 0,
+        isFinite(outTok) ? outTok : 0,
+        isFinite(thoughtTok) ? thoughtTok : 0,
+        isFinite(cachedTok) ? cachedTok : 0,
+      );
+      // Mirror legacy fields for compatibility
+      this.executionStats.inputTokens =
+        (this.executionStats.inputTokens || 0) + (isFinite(inTok) ? inTok : 0);
+      this.executionStats.outputTokens =
+        (this.executionStats.outputTokens || 0) +
+        (isFinite(outTok) ? outTok : 0);
+      this.executionStats.totalTokens =
+        (this.executionStats.inputTokens || 0) +
+        (this.executionStats.outputTokens || 0) +
+        (isFinite(thoughtTok) ? thoughtTok : 0) +
+        (isFinite(cachedTok) ? cachedTok : 0);
+      this.executionStats.estimatedCost =
+        (this.executionStats.inputTokens || 0) * 3e-5 +
+        (this.executionStats.outputTokens || 0) * 6e-5;
+    }
+    this.eventEmitter?.emit(AgentEventType.USAGE_METADATA, {
+      subagentId: this.subagentId,
+      round: turnCounter,
+      usage,
+      durationMs: Date.now() - roundStreamStart,
+      timestamp: Date.now(),
+    } as AgentUsageEvent);
+  }
+}
diff --git a/packages/core/src/subagents/subagent-events.ts b/packages/core/src/agents/runtime/agent-events.ts
similarity index 78%
rename from packages/core/src/subagents/subagent-events.ts
rename to packages/core/src/agents/runtime/agent-events.ts
index 5de09a3c2..8f68dd1c3 100644
--- a/packages/core/src/subagents/subagent-events.ts
+++ b/packages/core/src/agents/runtime/agent-events.ts
@@ -9,10 +9,10 @@ import type {
   ToolCallConfirmationDetails,
   ToolConfirmationOutcome,
   ToolResultDisplay,
-} from '../tools/tools.js';
+} from '../../tools/tools.js';
 import type { Part, GenerateContentResponseUsageMetadata } from '@google/genai';
 
-export type SubAgentEvent =
+export type AgentEvent =
   | 'start'
   | 'round_start'
   | 'round_end'
@@ -24,7 +24,7 @@ export type SubAgentEvent =
   | 'finish'
   | 'error';
 
-export enum SubAgentEventType {
+export enum AgentEventType {
   START = 'start',
   ROUND_START = 'round_start',
   ROUND_END = 'round_end',
@@ -37,7 +37,7 @@ export enum SubAgentEventType {
   ERROR = 'error',
 }
 
-export interface SubAgentStartEvent {
+export interface AgentStartEvent {
   subagentId: string;
   name: string;
   model?: string;
@@ -45,14 +45,14 @@ export interface SubAgentStartEvent {
   timestamp: number;
 }
 
-export interface SubAgentRoundEvent {
+export interface AgentRoundEvent {
   subagentId: string;
   round: number;
   promptId: string;
   timestamp: number;
 }
 
-export interface SubAgentStreamTextEvent {
+export interface AgentStreamTextEvent {
   subagentId: string;
   round: number;
   text: string;
@@ -61,7 +61,7 @@ export interface SubAgentStreamTextEvent {
   timestamp: number;
 }
 
-export interface SubAgentUsageEvent {
+export interface AgentUsageEvent {
   subagentId: string;
   round: number;
   usage: GenerateContentResponseUsageMetadata;
@@ -69,7 +69,7 @@ export interface SubAgentUsageEvent {
   timestamp: number;
 }
 
-export interface SubAgentToolCallEvent {
+export interface AgentToolCallEvent {
   subagentId: string;
   round: number;
   callId: string;
@@ -79,7 +79,7 @@ export interface SubAgentToolCallEvent {
   timestamp: number;
 }
 
-export interface SubAgentToolResultEvent {
+export interface AgentToolResultEvent {
   subagentId: string;
   round: number;
   callId: string;
@@ -92,7 +92,7 @@ export interface SubAgentToolResultEvent {
   timestamp: number;
 }
 
-export interface SubAgentApprovalRequestEvent {
+export interface AgentApprovalRequestEvent {
   subagentId: string;
   round: number;
   callId: string;
@@ -108,7 +108,7 @@ export interface SubAgentApprovalRequestEvent {
   timestamp: number;
 }
 
-export interface SubAgentFinishEvent {
+export interface AgentFinishEvent {
   subagentId: string;
   terminateReason: string;
   timestamp: number;
@@ -122,24 +122,24 @@ export interface SubAgentFinishEvent {
   totalTokens?: number;
 }
 
-export interface SubAgentErrorEvent {
+export interface AgentErrorEvent {
   subagentId: string;
   error: string;
   timestamp: number;
 }
 
-export class SubAgentEventEmitter {
+export class AgentEventEmitter {
   private ee = new EventEmitter();
 
-  on(event: SubAgentEvent, listener: (...args: unknown[]) => void) {
+  on(event: AgentEvent, listener: (...args: unknown[]) => void) {
     this.ee.on(event, listener);
   }
 
-  off(event: SubAgentEvent, listener: (...args: unknown[]) => void) {
+  off(event: AgentEvent, listener: (...args: unknown[]) => void) {
     this.ee.off(event, listener);
   }
 
-  emit(event: SubAgentEvent, payload: unknown) {
+  emit(event: AgentEvent, payload: unknown) {
     this.ee.emit(event, payload);
   }
 }
diff --git a/packages/core/src/subagents/subagent.test.ts b/packages/core/src/agents/runtime/agent-headless.test.ts
similarity index 87%
rename from packages/core/src/subagents/subagent.test.ts
rename to packages/core/src/agents/runtime/agent-headless.test.ts
index ce6e64ae4..41b31cddc 100644
--- a/packages/core/src/subagents/subagent.test.ts
+++ b/packages/core/src/agents/runtime/agent-headless.test.ts
@@ -21,39 +21,39 @@ import {
   vi,
   type Mock,
 } from 'vitest';
-import { Config, type ConfigParameters } from '../config/config.js';
-import { DEFAULT_QWEN_MODEL } from '../config/models.js';
+import { Config, type ConfigParameters } from '../../config/config.js';
+import { DEFAULT_QWEN_MODEL } from '../../config/models.js';
 import {
   createContentGenerator,
   createContentGeneratorConfig,
   resolveContentGeneratorConfigWithSources,
   AuthType,
-} from '../core/contentGenerator.js';
-import { GeminiChat } from '../core/geminiChat.js';
-import { executeToolCall } from '../core/nonInteractiveToolExecutor.js';
-import type { ToolRegistry } from '../tools/tool-registry.js';
-import { type AnyDeclarativeTool } from '../tools/tools.js';
-import { ContextState, SubAgentScope } from './subagent.js';
+} from '../../core/contentGenerator.js';
+import { GeminiChat } from '../../core/geminiChat.js';
+import { executeToolCall } from '../../core/nonInteractiveToolExecutor.js';
+import type { ToolRegistry } from '../../tools/tool-registry.js';
+import { type AnyDeclarativeTool } from '../../tools/tools.js';
+import { ContextState, AgentHeadless } from './agent-headless.js';
 import {
-  SubAgentEventEmitter,
-  SubAgentEventType,
-  type SubAgentStreamTextEvent,
-  type SubAgentToolCallEvent,
-  type SubAgentToolResultEvent,
-} from './subagent-events.js';
+  AgentEventEmitter,
+  AgentEventType,
+  type AgentStreamTextEvent,
+  type AgentToolCallEvent,
+  type AgentToolResultEvent,
+} from './agent-events.js';
 import type {
   ModelConfig,
   PromptConfig,
   RunConfig,
   ToolConfig,
-} from './types.js';
-import { SubagentTerminateMode } from './types.js';
+} from '../../subagents/types.js';
+import { SubagentTerminateMode } from '../../subagents/types.js';
 
-vi.mock('../core/geminiChat.js');
-vi.mock('../core/contentGenerator.js', async (importOriginal) => {
+vi.mock('../../core/geminiChat.js');
+vi.mock('../../core/contentGenerator.js', async (importOriginal) => {
   const actual =
-    await importOriginal<typeof import('../core/contentGenerator.js')>();
-  const { DEFAULT_QWEN_MODEL } = await import('../config/models.js');
+    await importOriginal<typeof import('../../core/contentGenerator.js')>();
+  const { DEFAULT_QWEN_MODEL } = await import('../../config/models.js');
   return {
     ...actual,
     createContentGenerator: vi.fn().mockResolvedValue({
@@ -77,7 +77,7 @@ vi.mock('../core/contentGenerator.js', async (importOriginal) => {
     }),
   };
 });
-vi.mock('../utils/environmentContext.js', () => ({
+vi.mock('../../utils/environmentContext.js', () => ({
   getEnvironmentContext: vi.fn().mockResolvedValue([{ text: 'Env Context' }]),
   getInitialChatHistory: vi.fn(async (_config, extraHistory) => [
     {
@@ -91,11 +91,11 @@ vi.mock('../utils/environmentContext.js', () => ({
     ...(extraHistory ?? []),
   ]),
 }));
-vi.mock('../core/nonInteractiveToolExecutor.js');
-vi.mock('../ide/ide-client.js');
-vi.mock('../core/client.js');
+vi.mock('../../core/nonInteractiveToolExecutor.js');
+vi.mock('../../ide/ide-client.js');
+vi.mock('../../core/client.js');
 
-vi.mock('../skills/skill-manager.js', () => {
+vi.mock('../../skills/skill-manager.js', () => {
   const SkillManagerMock = vi.fn();
   SkillManagerMock.prototype.startWatching = vi
     .fn()
@@ -107,7 +107,7 @@ vi.mock('../skills/skill-manager.js', () => {
   return { SkillManager: SkillManagerMock };
 });
 
-vi.mock('./subagent-manager.js', () => {
+vi.mock('../../subagents/subagent-manager.js', () => {
   const SubagentManagerMock = vi.fn();
   SubagentManagerMock.prototype.loadSessionSubagents = vi.fn();
   SubagentManagerMock.prototype.addChangeListener = vi
@@ -226,7 +226,7 @@ describe('subagent.ts', () => {
     });
   });
 
-  describe('SubAgentScope', () => {
+  describe('AgentHeadless', () => {
     let mockSendMessageStream: Mock;
 
     const defaultModelConfig: ModelConfig = {
@@ -299,16 +299,16 @@ describe('subagent.ts', () => {
     describe('create (Tool Validation)', () => {
       const promptConfig: PromptConfig = { systemPrompt: 'Test prompt' };
 
-      it('should create a SubAgentScope successfully with minimal config', async () => {
+      it('should create a AgentHeadless successfully with minimal config', async () => {
         const { config } = await createMockConfig();
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
           defaultModelConfig,
           defaultRunConfig,
         );
-        expect(scope).toBeInstanceOf(SubAgentScope);
+        expect(scope).toBeInstanceOf(AgentHeadless);
       });
 
       it('should not block creation when a tool may require confirmation', async () => {
@@ -331,7 +331,7 @@ describe('subagent.ts', () => {
 
         const toolConfig: ToolConfig = { tools: ['risky_tool'] };
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -339,7 +339,7 @@ describe('subagent.ts', () => {
           defaultRunConfig,
           toolConfig,
         );
-        expect(scope).toBeInstanceOf(SubAgentScope);
+        expect(scope).toBeInstanceOf(AgentHeadless);
       });
 
       it('should succeed if tools do not require confirmation', async () => {
@@ -357,7 +357,7 @@ describe('subagent.ts', () => {
 
         const toolConfig: ToolConfig = { tools: ['safe_tool'] };
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -365,7 +365,7 @@ describe('subagent.ts', () => {
           defaultRunConfig,
           toolConfig,
         );
-        expect(scope).toBeInstanceOf(SubAgentScope);
+        expect(scope).toBeInstanceOf(AgentHeadless);
       });
 
       it('should allow creation regardless of tool parameter requirements', async () => {
@@ -390,7 +390,7 @@ describe('subagent.ts', () => {
 
         const toolConfig: ToolConfig = { tools: ['tool_with_params'] };
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -399,13 +399,13 @@ describe('subagent.ts', () => {
           toolConfig,
         );
 
-        expect(scope).toBeInstanceOf(SubAgentScope);
+        expect(scope).toBeInstanceOf(AgentHeadless);
         // Ensure build was not called during creation
         expect(mockToolWithParams.build).not.toHaveBeenCalled();
       });
     });
 
-    describe('runNonInteractive - Initialization and Prompting', () => {
+    describe('execute - Initialization and Prompting', () => {
       it('should correctly template the system prompt and initialize GeminiChat', async () => {
         const { config } = await createMockConfig();
 
@@ -421,7 +421,7 @@ describe('subagent.ts', () => {
         // Model stops immediately
         mockSendMessageStream.mockImplementation(createMockStream(['stop']));
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -429,7 +429,7 @@ describe('subagent.ts', () => {
           defaultRunConfig,
         );
 
-        await scope.runNonInteractive(context);
+        await scope.execute(context);
 
         // Check if GeminiChat was initialized correctly by the subagent
         expect(GeminiChat).toHaveBeenCalledTimes(1);
@@ -471,7 +471,7 @@ describe('subagent.ts', () => {
         // Model stops immediately
         mockSendMessageStream.mockImplementation(createMockStream(['stop']));
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -479,7 +479,7 @@ describe('subagent.ts', () => {
           defaultRunConfig,
         );
 
-        await scope.runNonInteractive(context);
+        await scope.execute(context);
 
         const callArgs = vi.mocked(GeminiChat).mock.calls[0];
         const generationConfig = getGenerationConfigFromMock();
@@ -505,7 +505,7 @@ describe('subagent.ts', () => {
         context.set('name', 'Agent');
         // 'missing' is not set
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -513,8 +513,8 @@ describe('subagent.ts', () => {
           defaultRunConfig,
         );
 
-        // The error from templating causes the runNonInteractive to reject and the terminate_reason to be ERROR.
-        await expect(scope.runNonInteractive(context)).rejects.toThrow(
+        // The error from templating causes the execute to reject and the terminate_reason to be ERROR.
+        await expect(scope.execute(context)).rejects.toThrow(
           'Missing context values for the following keys: missing',
         );
         expect(scope.getTerminateMode()).toBe(SubagentTerminateMode.ERROR);
@@ -528,7 +528,7 @@ describe('subagent.ts', () => {
         };
         const context = new ContextState();
 
-        const agent = await SubAgentScope.create(
+        const agent = await AgentHeadless.create(
           'TestAgent',
           config,
           promptConfig,
@@ -536,14 +536,14 @@ describe('subagent.ts', () => {
           defaultRunConfig,
         );
 
-        await expect(agent.runNonInteractive(context)).rejects.toThrow(
+        await expect(agent.execute(context)).rejects.toThrow(
           'PromptConfig cannot have both `systemPrompt` and `initialMessages` defined.',
         );
         expect(agent.getTerminateMode()).toBe(SubagentTerminateMode.ERROR);
       });
     });
 
-    describe('runNonInteractive - Execution and Tool Use', () => {
+    describe('execute - Execution and Tool Use', () => {
       const promptConfig: PromptConfig = { systemPrompt: 'Execute task.' };
 
       it('should terminate with GOAL if no outputs are expected and model stops', async () => {
@@ -551,7 +551,7 @@ describe('subagent.ts', () => {
         // Model stops immediately
         mockSendMessageStream.mockImplementation(createMockStream(['stop']));
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -560,7 +560,7 @@ describe('subagent.ts', () => {
           // No ToolConfig, No OutputConfig
         );
 
-        await scope.runNonInteractive(new ContextState());
+        await scope.execute(new ContextState());
 
         expect(scope.getTerminateMode()).toBe(SubagentTerminateMode.GOAL);
         expect(mockSendMessageStream).toHaveBeenCalledTimes(1);
@@ -576,7 +576,7 @@ describe('subagent.ts', () => {
         // Model stops immediately with text response
         mockSendMessageStream.mockImplementation(createMockStream(['stop']));
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -584,7 +584,7 @@ describe('subagent.ts', () => {
           defaultRunConfig,
         );
 
-        await scope.runNonInteractive(new ContextState());
+        await scope.execute(new ContextState());
 
         expect(scope.getTerminateMode()).toBe(SubagentTerminateMode.GOAL);
         expect(mockSendMessageStream).toHaveBeenCalledTimes(1);
@@ -647,7 +647,7 @@ describe('subagent.ts', () => {
           name === 'list_files' ? listFilesTool : undefined,
         );
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -656,7 +656,7 @@ describe('subagent.ts', () => {
           toolConfig,
         );
 
-        await scope.runNonInteractive(new ContextState());
+        await scope.execute(new ContextState());
 
         // Check the response sent back to the model (functionResponse part)
         const secondCallArgs = mockSendMessageStream.mock.calls[1][1];
@@ -671,7 +671,7 @@ describe('subagent.ts', () => {
       });
     });
 
-    describe('runNonInteractive - Termination and Recovery', () => {
+    describe('execute - Termination and Recovery', () => {
       const promptConfig: PromptConfig = { systemPrompt: 'Execute task.' };
 
       it('should terminate with MAX_TURNS if the limit is reached', async () => {
@@ -703,7 +703,7 @@ describe('subagent.ts', () => {
           ]),
         );
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -711,7 +711,7 @@ describe('subagent.ts', () => {
           runConfig,
         );
 
-        await scope.runNonInteractive(new ContextState());
+        await scope.execute(new ContextState());
 
         expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
         expect(scope.getTerminateMode()).toBe(SubagentTerminateMode.MAX_TURNS);
@@ -738,7 +738,7 @@ describe('subagent.ts', () => {
         // The LLM call will hang until we resolve the promise.
         mockSendMessageStream.mockReturnValue(streamPromise);
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -746,7 +746,7 @@ describe('subagent.ts', () => {
           runConfig,
         );
 
-        const runPromise = scope.runNonInteractive(new ContextState());
+        const runPromise = scope.execute(new ContextState());
 
         // Advance time beyond the limit (6 minutes) while the agent is awaiting the LLM response.
         await vi.advanceTimersByTimeAsync(6 * 60 * 1000);
@@ -767,7 +767,7 @@ describe('subagent.ts', () => {
         const { config } = await createMockConfig();
         mockSendMessageStream.mockRejectedValue(new Error('API Failure'));
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -775,14 +775,14 @@ describe('subagent.ts', () => {
           defaultRunConfig,
         );
 
-        await expect(
-          scope.runNonInteractive(new ContextState()),
-        ).rejects.toThrow('API Failure');
+        await expect(scope.execute(new ContextState())).rejects.toThrow(
+          'API Failure',
+        );
         expect(scope.getTerminateMode()).toBe(SubagentTerminateMode.ERROR);
       });
     });
 
-    describe('runNonInteractive - Streaming and Thought Handling', () => {
+    describe('execute - Streaming and Thought Handling', () => {
       const promptConfig: PromptConfig = { systemPrompt: 'Execute task.' };
 
       // Helper to create a mock stream that yields specific parts
@@ -816,13 +816,13 @@ describe('subagent.ts', () => {
             }) as unknown as GeminiChat,
         );
 
-        const eventEmitter = new SubAgentEventEmitter();
-        const events: SubAgentStreamTextEvent[] = [];
-        eventEmitter.on(SubAgentEventType.STREAM_TEXT, (...args: unknown[]) => {
-          events.push(args[0] as SubAgentStreamTextEvent);
+        const eventEmitter = new AgentEventEmitter();
+        const events: AgentStreamTextEvent[] = [];
+        eventEmitter.on(AgentEventType.STREAM_TEXT, (...args: unknown[]) => {
+          events.push(args[0] as AgentStreamTextEvent);
         });
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -832,7 +832,7 @@ describe('subagent.ts', () => {
           eventEmitter,
         );
 
-        await scope.runNonInteractive(new ContextState());
+        await scope.execute(new ContextState());
 
         expect(events).toHaveLength(2);
         expect(events[0]!.text).toBe('Let me think...');
@@ -855,7 +855,7 @@ describe('subagent.ts', () => {
             }) as unknown as GeminiChat,
         );
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -863,7 +863,7 @@ describe('subagent.ts', () => {
           defaultRunConfig,
         );
 
-        await scope.runNonInteractive(new ContextState());
+        await scope.execute(new ContextState());
 
         expect(scope.getTerminateMode()).toBe(SubagentTerminateMode.GOAL);
         expect(scope.getFinalText()).toBe('The final answer.');
@@ -919,7 +919,7 @@ describe('subagent.ts', () => {
             }) as unknown as GeminiChat,
         );
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -927,7 +927,7 @@ describe('subagent.ts', () => {
           defaultRunConfig,
         );
 
-        await scope.runNonInteractive(new ContextState());
+        await scope.execute(new ContextState());
 
         expect(scope.getTerminateMode()).toBe(SubagentTerminateMode.GOAL);
         expect(scope.getFinalText()).toBe('Actual output.');
@@ -936,7 +936,7 @@ describe('subagent.ts', () => {
       });
     });
 
-    describe('runNonInteractive - Tool Restriction Enforcement (Issue #1121)', () => {
+    describe('execute - Tool Restriction Enforcement (Issue #1121)', () => {
       const promptConfig: PromptConfig = { systemPrompt: 'Execute task.' };
 
       it('should NOT execute tools that are not in the allowed tools list', async () => {
@@ -1045,19 +1045,19 @@ describe('subagent.ts', () => {
         );
 
         // Track emitted events
-        const toolCallEvents: SubAgentToolCallEvent[] = [];
-        const toolResultEvents: SubAgentToolResultEvent[] = [];
+        const toolCallEvents: AgentToolCallEvent[] = [];
+        const toolResultEvents: AgentToolResultEvent[] = [];
 
         // Create event emitter BEFORE the scope and subscribe to events
-        const eventEmitter = new SubAgentEventEmitter();
-        eventEmitter.on(SubAgentEventType.TOOL_CALL, (event: unknown) => {
-          toolCallEvents.push(event as SubAgentToolCallEvent);
+        const eventEmitter = new AgentEventEmitter();
+        eventEmitter.on(AgentEventType.TOOL_CALL, (event: unknown) => {
+          toolCallEvents.push(event as AgentToolCallEvent);
         });
-        eventEmitter.on(SubAgentEventType.TOOL_RESULT, (event: unknown) => {
-          toolResultEvents.push(event as SubAgentToolResultEvent);
+        eventEmitter.on(AgentEventType.TOOL_RESULT, (event: unknown) => {
+          toolResultEvents.push(event as AgentToolResultEvent);
         });
 
-        const scope = await SubAgentScope.create(
+        const scope = await AgentHeadless.create(
           'test-agent',
           config,
           promptConfig,
@@ -1067,7 +1067,7 @@ describe('subagent.ts', () => {
           eventEmitter,
         );
 
-        await scope.runNonInteractive(new ContextState());
+        await scope.execute(new ContextState());
 
         // 1. Only allowed tool should be executed
         expect(executedTools).toContain('read_file');
diff --git a/packages/core/src/agents/runtime/agent-headless.ts b/packages/core/src/agents/runtime/agent-headless.ts
new file mode 100644
index 000000000..ce97d143b
--- /dev/null
+++ b/packages/core/src/agents/runtime/agent-headless.ts
@@ -0,0 +1,362 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview AgentHeadless — one-shot task execution wrapper around AgentCore.
+ *
+ * AgentHeadless manages
+ * the lifecycle of a single headless task: start → run → finish.
+ * It delegates all model reasoning and tool scheduling to AgentCore.
+ *
+ * For persistent interactive agents, see AgentInteractive (Phase 2).
+ */
+
+import type { Config } from '../../config/config.js';
+import { createDebugLogger } from '../../utils/debugLogger.js';
+import type { AgentEventEmitter } from './agent-events.js';
+import { AgentEventType } from './agent-events.js';
+import type {
+  AgentStartEvent,
+  AgentErrorEvent,
+  AgentFinishEvent,
+} from './agent-events.js';
+import type { AgentStatsSummary } from './agent-statistics.js';
+import type { AgentHooks } from './agent-hooks.js';
+import type {
+  PromptConfig,
+  ModelConfig,
+  RunConfig,
+  ToolConfig,
+} from '../../subagents/types.js';
+import { SubagentTerminateMode } from '../../subagents/types.js';
+import { logSubagentExecution } from '../../telemetry/loggers.js';
+import { SubagentExecutionEvent } from '../../telemetry/types.js';
+import { AgentCore } from './agent-core.js';
+import { DEFAULT_QWEN_MODEL } from '../../config/models.js';
+
+const debugLogger = createDebugLogger('SUBAGENT');
+
+// ─── Utilities (unchanged, re-exported for consumers) ────────
+
+/**
+ * Manages the runtime context state for the subagent.
+ * This class provides a mechanism to store and retrieve key-value pairs
+ * that represent the dynamic state and variables accessible to the subagent
+ * during its execution.
+ */
+export class ContextState {
+  private state: Record<string, unknown> = {};
+
+  /**
+   * Retrieves a value from the context state.
+   *
+   * @param key - The key of the value to retrieve.
+   * @returns The value associated with the key, or undefined if the key is not found.
+   */
+  get(key: string): unknown {
+    return this.state[key];
+  }
+
+  /**
+   * Sets a value in the context state.
+   *
+   * @param key - The key to set the value under.
+   * @param value - The value to set.
+   */
+  set(key: string, value: unknown): void {
+    this.state[key] = value;
+  }
+
+  /**
+   * Retrieves all keys in the context state.
+   *
+   * @returns An array of all keys in the context state.
+   */
+  get_keys(): string[] {
+    return Object.keys(this.state);
+  }
+}
+
+/**
+ * Replaces `${...}` placeholders in a template string with values from a context.
+ *
+ * This function identifies all placeholders in the format `${key}`, validates that
+ * each key exists in the provided `ContextState`, and then performs the substitution.
+ *
+ * @param template The template string containing placeholders.
+ * @param context The `ContextState` object providing placeholder values.
+ * @returns The populated string with all placeholders replaced.
+ * @throws {Error} if any placeholder key is not found in the context.
+ */
+export function templateString(
+  template: string,
+  context: ContextState,
+): string {
+  const placeholderRegex = /\$\{(\w+)\}/g;
+
+  // First, find all unique keys required by the template.
+  const requiredKeys = new Set(
+    Array.from(template.matchAll(placeholderRegex), (match) => match[1]),
+  );
+
+  // Check if all required keys exist in the context.
+  const contextKeys = new Set(context.get_keys());
+  const missingKeys = Array.from(requiredKeys).filter(
+    (key) => !contextKeys.has(key),
+  );
+
+  if (missingKeys.length > 0) {
+    throw new Error(
+      `Missing context values for the following keys: ${missingKeys.join(
+        ', ',
+      )}`,
+    );
+  }
+
+  // Perform the replacement using a replacer function.
+  return template.replace(placeholderRegex, (_match, key) =>
+    String(context.get(key)),
+  );
+}
+
+// ─── AgentHeadless ──────────────────────────────────────────
+
+/**
+ * AgentHeadless — one-shot task executor.
+ *
+ * Takes a task, runs it through AgentCore's reasoning loop, and returns
+ * the result.
+ *
+ * Lifecycle: Born → execute() → die.
+ */
+export class AgentHeadless {
+  private readonly core: AgentCore;
+  private finalText: string = '';
+  private terminateMode: SubagentTerminateMode = SubagentTerminateMode.ERROR;
+
+  private constructor(core: AgentCore) {
+    this.core = core;
+  }
+
+  /**
+   * Creates a new AgentHeadless instance.
+   *
+   * @param name - The name for the subagent, used for logging and identification.
+   * @param runtimeContext - The shared runtime configuration and services.
+   * @param promptConfig - Configuration for the subagent's prompt and behavior.
+   * @param modelConfig - Configuration for the generative model parameters.
+   * @param runConfig - Configuration for the subagent's execution environment.
+   * @param toolConfig - Optional configuration for tools available to the subagent.
+   * @param eventEmitter - Optional event emitter for streaming events to UI.
+   * @param hooks - Optional lifecycle hooks.
+   */
+  static async create(
+    name: string,
+    runtimeContext: Config,
+    promptConfig: PromptConfig,
+    modelConfig: ModelConfig,
+    runConfig: RunConfig,
+    toolConfig?: ToolConfig,
+    eventEmitter?: AgentEventEmitter,
+    hooks?: AgentHooks,
+  ): Promise<AgentHeadless> {
+    const core = new AgentCore(
+      name,
+      runtimeContext,
+      promptConfig,
+      modelConfig,
+      runConfig,
+      toolConfig,
+      eventEmitter,
+      hooks,
+    );
+    return new AgentHeadless(core);
+  }
+
+  /**
+   * Executes the task in headless mode.
+   *
+   * This method orchestrates the subagent's execution lifecycle:
+   * 1. Creates a chat session
+   * 2. Prepares tools
+   * 3. Runs the reasoning loop until completion/termination
+   * 4. Emits start/finish/error events
+   * 5. Records telemetry
+   *
+   * @param context - The current context state containing variables for prompt templating.
+   * @param externalSignal - Optional abort signal for external cancellation.
+   */
+  async execute(
+    context: ContextState,
+    externalSignal?: AbortSignal,
+  ): Promise<void> {
+    const chat = await this.core.createChat(context);
+
+    if (!chat) {
+      this.terminateMode = SubagentTerminateMode.ERROR;
+      return;
+    }
+
+    // Set up abort signal propagation
+    const abortController = new AbortController();
+    const onExternalAbort = () => {
+      abortController.abort();
+    };
+    if (externalSignal) {
+      externalSignal.addEventListener('abort', onExternalAbort);
+    }
+    if (externalSignal?.aborted) {
+      abortController.abort();
+    }
+
+    const toolsList = this.core.prepareTools();
+
+    const initialTaskText = String(
+      (context.get('task_prompt') as string) ?? 'Get Started!',
+    );
+    const initialMessages = [
+      { role: 'user' as const, parts: [{ text: initialTaskText }] },
+    ];
+
+    const startTime = Date.now();
+    this.core.executionStats.startTimeMs = startTime;
+    this.core.stats.start(startTime);
+
+    try {
+      // Emit start event
+      this.core.eventEmitter?.emit(AgentEventType.START, {
+        subagentId: this.core.subagentId,
+        name: this.core.name,
+        model:
+          this.core.modelConfig.model ||
+          this.core.runtimeContext.getModel() ||
+          DEFAULT_QWEN_MODEL,
+        tools: (this.core.toolConfig?.tools || ['*']).map((t) =>
+          typeof t === 'string' ? t : t.name,
+        ),
+        timestamp: Date.now(),
+      } as AgentStartEvent);
+
+      // Log telemetry for subagent start
+      const startEvent = new SubagentExecutionEvent(this.core.name, 'started');
+      logSubagentExecution(this.core.runtimeContext, startEvent);
+
+      // Delegate to AgentCore's reasoning loop
+      const result = await this.core.runReasoningLoop(
+        chat,
+        initialMessages,
+        toolsList,
+        abortController,
+        {
+          maxTurns: this.core.runConfig.max_turns,
+          maxTimeMinutes: this.core.runConfig.max_time_minutes,
+          startTimeMs: startTime,
+        },
+      );
+
+      this.finalText = result.text;
+      this.terminateMode = result.terminateMode ?? SubagentTerminateMode.GOAL;
+    } catch (error) {
+      debugLogger.error('Error during subagent execution:', error);
+      this.terminateMode = SubagentTerminateMode.ERROR;
+      this.core.eventEmitter?.emit(AgentEventType.ERROR, {
+        subagentId: this.core.subagentId,
+        error: error instanceof Error ? error.message : String(error),
+        timestamp: Date.now(),
+      } as AgentErrorEvent);
+
+      throw error;
+    } finally {
+      if (externalSignal) {
+        externalSignal.removeEventListener('abort', onExternalAbort);
+      }
+      this.core.executionStats.totalDurationMs = Date.now() - startTime;
+      const summary = this.core.stats.getSummary(Date.now());
+      this.core.eventEmitter?.emit(AgentEventType.FINISH, {
+        subagentId: this.core.subagentId,
+        terminateReason: this.terminateMode,
+        timestamp: Date.now(),
+        rounds: summary.rounds,
+        totalDurationMs: summary.totalDurationMs,
+        totalToolCalls: summary.totalToolCalls,
+        successfulToolCalls: summary.successfulToolCalls,
+        failedToolCalls: summary.failedToolCalls,
+        inputTokens: summary.inputTokens,
+        outputTokens: summary.outputTokens,
+        totalTokens: summary.totalTokens,
+      } as AgentFinishEvent);
+
+      const completionEvent = new SubagentExecutionEvent(
+        this.core.name,
+        this.terminateMode === SubagentTerminateMode.GOAL
+          ? 'completed'
+          : 'failed',
+        {
+          terminate_reason: this.terminateMode,
+          result: this.finalText,
+          execution_summary: this.core.stats.formatCompact(
+            'Subagent execution completed',
+          ),
+        },
+      );
+      logSubagentExecution(this.core.runtimeContext, completionEvent);
+
+      await this.core.hooks?.onStop?.({
+        subagentId: this.core.subagentId,
+        name: this.core.name,
+        terminateReason: this.terminateMode,
+        summary: summary as unknown as Record<string, unknown>,
+        timestamp: Date.now(),
+      });
+    }
+  }
+
+  // ─── Accessors ─────────────────────────────────────────────
+
+  /**
+   * Provides access to the underlying AgentCore for advanced use cases.
+   * Used by AgentInteractive and InProcessBackend.
+   */
+  getCore(): AgentCore {
+    return this.core;
+  }
+
+  get executionStats() {
+    return this.core.executionStats;
+  }
+
+  set executionStats(value) {
+    this.core.executionStats = value;
+  }
+
+  getEventEmitter() {
+    return this.core.getEventEmitter();
+  }
+
+  getStatistics() {
+    return this.core.getStatistics();
+  }
+
+  getExecutionSummary(): AgentStatsSummary {
+    return this.core.getExecutionSummary();
+  }
+
+  getFinalText(): string {
+    return this.finalText;
+  }
+
+  getTerminateMode(): SubagentTerminateMode {
+    return this.terminateMode;
+  }
+
+  get name(): string {
+    return this.core.name;
+  }
+
+  get runtimeContext(): Config {
+    return this.core.runtimeContext;
+  }
+}
diff --git a/packages/core/src/subagents/subagent-hooks.ts b/packages/core/src/agents/runtime/agent-hooks.ts
similarity index 83%
rename from packages/core/src/subagents/subagent-hooks.ts
rename to packages/core/src/agents/runtime/agent-hooks.ts
index f3bf997bf..76b65f95e 100644
--- a/packages/core/src/subagents/subagent-hooks.ts
+++ b/packages/core/src/agents/runtime/agent-hooks.ts
@@ -18,7 +18,7 @@ export interface PostToolUsePayload extends PreToolUsePayload {
   errorMessage?: string;
 }
 
-export interface SubagentStopPayload {
+export interface AgentStopPayload {
   subagentId: string;
   name: string; // subagent name
   terminateReason: string;
@@ -26,8 +26,8 @@ export interface SubagentStopPayload {
   timestamp: number;
 }
 
-export interface SubagentHooks {
+export interface AgentHooks {
   preToolUse?(payload: PreToolUsePayload): Promise<void> | void;
   postToolUse?(payload: PostToolUsePayload): Promise<void> | void;
-  onStop?(payload: SubagentStopPayload): Promise<void> | void;
+  onStop?(payload: AgentStopPayload): Promise<void> | void;
 }
diff --git a/packages/core/src/subagents/subagent-statistics.test.ts b/packages/core/src/agents/runtime/agent-statistics.test.ts
similarity index 98%
rename from packages/core/src/subagents/subagent-statistics.test.ts
rename to packages/core/src/agents/runtime/agent-statistics.test.ts
index 39ba70aa4..5da21c17d 100644
--- a/packages/core/src/subagents/subagent-statistics.test.ts
+++ b/packages/core/src/agents/runtime/agent-statistics.test.ts
@@ -5,14 +5,14 @@
  */
 
 import { describe, it, expect, beforeEach } from 'vitest';
-import { SubagentStatistics } from './subagent-statistics.js';
+import { AgentStatistics } from './agent-statistics.js';
 
-describe('SubagentStatistics', () => {
-  let stats: SubagentStatistics;
+describe('AgentStatistics', () => {
+  let stats: AgentStatistics;
   const baseTime = 1000000000000; // Fixed timestamp for consistent testing
 
   beforeEach(() => {
-    stats = new SubagentStatistics();
+    stats = new AgentStatistics();
   });
 
   describe('basic statistics tracking', () => {
diff --git a/packages/core/src/subagents/subagent-statistics.ts b/packages/core/src/agents/runtime/agent-statistics.ts
similarity index 97%
rename from packages/core/src/subagents/subagent-statistics.ts
rename to packages/core/src/agents/runtime/agent-statistics.ts
index 72308c633..8487d5e0b 100644
--- a/packages/core/src/subagents/subagent-statistics.ts
+++ b/packages/core/src/agents/runtime/agent-statistics.ts
@@ -14,7 +14,7 @@ export interface ToolUsageStats {
   averageDurationMs: number;
 }
 
-export interface SubagentStatsSummary {
+export interface AgentStatsSummary {
   rounds: number;
   totalDurationMs: number;
   totalToolCalls: number;
@@ -30,7 +30,7 @@ export interface SubagentStatsSummary {
   toolUsage: ToolUsageStats[];
 }
 
-export class SubagentStatistics {
+export class AgentStatistics {
   private startTimeMs = 0;
   private rounds = 0;
   private totalToolCalls = 0;
@@ -90,7 +90,7 @@ export class SubagentStatistics {
     this.cachedTokens += Math.max(0, cached || 0);
   }
 
-  getSummary(now = Date.now()): SubagentStatsSummary {
+  getSummary(now = Date.now()): AgentStatsSummary {
     const totalDurationMs = this.startTimeMs ? now - this.startTimeMs : 0;
     const totalToolCalls = this.totalToolCalls;
     const successRate =
@@ -217,7 +217,7 @@ export class SubagentStatistics {
     return `${h}h ${m}m`;
   }
 
-  private generatePerformanceTips(stats: SubagentStatsSummary): string[] {
+  private generatePerformanceTips(stats: AgentStatsSummary): string[] {
     const tips: string[] = [];
     const totalCalls = stats.totalToolCalls;
     const sr =
diff --git a/packages/core/src/agents/runtime/index.ts b/packages/core/src/agents/runtime/index.ts
new file mode 100644
index 000000000..025790798
--- /dev/null
+++ b/packages/core/src/agents/runtime/index.ts
@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Runtime barrel — re-exports agent execution primitives.
+ */
+
+export * from './agent-core.js';
+export * from './agent-headless.js';
+export * from './agent-events.js';
+export * from './agent-statistics.js';
+export * from './agent-hooks.js';
diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts
index 964880b4e..0d7fd5a09 100644
--- a/packages/core/src/config/config.ts
+++ b/packages/core/src/config/config.ts
@@ -21,8 +21,8 @@ import type { ContentGeneratorConfigSources } from '../core/contentGenerator.js'
 import type { MCPOAuthConfig } from '../mcp/oauth-provider.js';
 import type { ShellExecutionConfig } from '../services/shellExecutionService.js';
 import type { AnyToolInvocation } from '../tools/tools.js';
-import type { ArenaManager } from '../agents-collab/arena/ArenaManager.js';
-import { ArenaAgentClient } from '../agents-collab/arena/ArenaAgentClient.js';
+import type { ArenaManager } from '../agents/arena/ArenaManager.js';
+import { ArenaAgentClient } from '../agents/arena/ArenaAgentClient.js';
 
 // Core
 import { BaseLlmClient } from '../core/baseLlmClient.js';
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 4c34412c2..6b6b18351 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -131,7 +131,7 @@ export * from './tools/tool-registry.js';
 export * from './subagents/index.js';
 
 // Export shared multi-agent infrastructure
-export * from './agents-collab/index.js';
+export * from './agents/index.js';
 
 // Export skills
 export * from './skills/index.js';
diff --git a/packages/core/src/services/gitWorktreeService.ts b/packages/core/src/services/gitWorktreeService.ts
index 5f0b8bd1b..e1a359873 100644
--- a/packages/core/src/services/gitWorktreeService.ts
+++ b/packages/core/src/services/gitWorktreeService.ts
@@ -11,7 +11,7 @@ import type { SimpleGit } from 'simple-git';
 import { Storage } from '../config/storage.js';
 import { isCommandAvailable } from '../utils/shell-utils.js';
 import { isNodeError } from '../utils/errors.js';
-import type { ArenaConfigFile } from '../agents-collab/arena/types.js';
+import type { ArenaConfigFile } from '../agents/arena/types.js';
 
 /**
  * Commit message used for the baseline snapshot in arena worktrees.
diff --git a/packages/core/src/subagents/index.ts b/packages/core/src/subagents/index.ts
index 17c62a200..f877d23d8 100644
--- a/packages/core/src/subagents/index.ts
+++ b/packages/core/src/subagents/index.ts
@@ -8,7 +8,7 @@
  * @fileoverview Subagents Phase 1 implementation - File-based configuration layer
  *
  * This module provides the foundation for the subagents feature by implementing
- * a file-based configuration system that builds on the existing SubAgentScope
+ * a file-based configuration system that builds on the AgentHeadless
  * runtime system. It includes:
  *
  * - Type definitions for file-based subagent configurations
@@ -50,26 +50,29 @@ export type {
   SubagentTerminateMode,
 } from './types.js';
 
-export { SubAgentScope } from './subagent.js';
+export { AgentHeadless } from '../agents/runtime/agent-headless.js';
 
 // Event system for UI integration
 export type {
-  SubAgentEvent,
-  SubAgentStartEvent,
-  SubAgentRoundEvent,
-  SubAgentStreamTextEvent,
-  SubAgentUsageEvent,
-  SubAgentToolCallEvent,
-  SubAgentToolResultEvent,
-  SubAgentFinishEvent,
-  SubAgentErrorEvent,
-  SubAgentApprovalRequestEvent,
-} from './subagent-events.js';
+  AgentEvent,
+  AgentStartEvent,
+  AgentRoundEvent,
+  AgentStreamTextEvent,
+  AgentUsageEvent,
+  AgentToolCallEvent,
+  AgentToolResultEvent,
+  AgentFinishEvent,
+  AgentErrorEvent,
+  AgentApprovalRequestEvent,
+} from '../agents/runtime/agent-events.js';
 
-export { SubAgentEventEmitter, SubAgentEventType } from './subagent-events.js';
+export {
+  AgentEventEmitter,
+  AgentEventType,
+} from '../agents/runtime/agent-events.js';
 
 // Statistics and formatting
 export type {
-  SubagentStatsSummary,
+  AgentStatsSummary,
   ToolUsageStats,
-} from './subagent-statistics.js';
+} from '../agents/runtime/agent-statistics.js';
diff --git a/packages/core/src/subagents/subagent-manager.ts b/packages/core/src/subagents/subagent-manager.ts
index fea33040c..b2fa2c47e 100644
--- a/packages/core/src/subagents/subagent-manager.ts
+++ b/packages/core/src/subagents/subagent-manager.ts
@@ -26,7 +26,9 @@ import type {
 } from './types.js';
 import { SubagentError, SubagentErrorCode } from './types.js';
 import { SubagentValidator } from './validation.js';
-import { SubAgentScope } from './subagent.js';
+import { AgentHeadless } from '../agents/runtime/agent-headless.js';
+import type { AgentEventEmitter } from '../agents/runtime/agent-events.js';
+import type { AgentHooks } from '../agents/runtime/agent-hooks.js';
 import type { Config } from '../config/config.js';
 import { createDebugLogger } from '../utils/debugLogger.js';
 
@@ -578,24 +580,24 @@ export class SubagentManager {
   }
 
   /**
-   * Creates a SubAgentScope from a subagent configuration.
+   * Creates an AgentHeadless from a subagent configuration.
    *
    * @param config - Subagent configuration
    * @param runtimeContext - Runtime context
-   * @returns Promise resolving to SubAgentScope
+   * @returns Promise resolving to AgentHeadless
    */
-  async createSubagentScope(
+  async createAgentHeadless(
     config: SubagentConfig,
     runtimeContext: Config,
     options?: {
-      eventEmitter?: import('./subagent-events.js').SubAgentEventEmitter;
-      hooks?: import('./subagent-hooks.js').SubagentHooks;
+      eventEmitter?: AgentEventEmitter;
+      hooks?: AgentHooks;
     },
-  ): Promise<SubAgentScope> {
+  ): Promise<AgentHeadless> {
     try {
       const runtimeConfig = this.convertToRuntimeConfig(config);
 
-      return await SubAgentScope.create(
+      return await AgentHeadless.create(
         config.name,
         runtimeContext,
         runtimeConfig.promptConfig,
@@ -608,7 +610,7 @@ export class SubagentManager {
     } catch (error) {
       if (error instanceof Error) {
         throw new SubagentError(
-          `Failed to create SubAgentScope: ${error.message}`,
+          `Failed to create AgentHeadless: ${error.message}`,
           SubagentErrorCode.INVALID_CONFIG,
           config.name,
         );
@@ -619,10 +621,10 @@ export class SubagentManager {
 
   /**
    * Converts a file-based SubagentConfig to runtime configuration
-   * compatible with SubAgentScope.create().
+   * compatible with AgentHeadless.create().
    *
    * @param config - File-based subagent configuration
-   * @returns Runtime configuration for SubAgentScope
+   * @returns Runtime configuration for AgentHeadless
    */
   convertToRuntimeConfig(config: SubagentConfig): SubagentRuntimeConfig {
     // Build prompt configuration
diff --git a/packages/core/src/subagents/subagent.ts b/packages/core/src/subagents/subagent.ts
deleted file mode 100644
index c9328e5ad..000000000
--- a/packages/core/src/subagents/subagent.ts
+++ /dev/null
@@ -1,1004 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { reportError } from '../utils/errorReporting.js';
-import type { Config } from '../config/config.js';
-import { createDebugLogger } from '../utils/debugLogger.js';
-
-const debugLogger = createDebugLogger('SUBAGENT');
-import { type ToolCallRequestInfo } from '../core/turn.js';
-import {
-  CoreToolScheduler,
-  type ToolCall,
-  type WaitingToolCall,
-} from '../core/coreToolScheduler.js';
-import type {
-  ToolConfirmationOutcome,
-  ToolCallConfirmationDetails,
-} from '../tools/tools.js';
-import { getInitialChatHistory } from '../utils/environmentContext.js';
-import type {
-  Content,
-  Part,
-  FunctionCall,
-  GenerateContentConfig,
-  FunctionDeclaration,
-  GenerateContentResponseUsageMetadata,
-} from '@google/genai';
-import { GeminiChat } from '../core/geminiChat.js';
-import type {
-  PromptConfig,
-  ModelConfig,
-  RunConfig,
-  ToolConfig,
-} from './types.js';
-import { SubagentTerminateMode } from './types.js';
-import type {
-  SubAgentFinishEvent,
-  SubAgentRoundEvent,
-  SubAgentStartEvent,
-  SubAgentToolCallEvent,
-  SubAgentToolResultEvent,
-  SubAgentErrorEvent,
-  SubAgentUsageEvent,
-} from './subagent-events.js';
-import {
-  type SubAgentEventEmitter,
-  SubAgentEventType,
-} from './subagent-events.js';
-import {
-  SubagentStatistics,
-  type SubagentStatsSummary,
-} from './subagent-statistics.js';
-import type { SubagentHooks } from './subagent-hooks.js';
-import { logSubagentExecution } from '../telemetry/loggers.js';
-import { SubagentExecutionEvent } from '../telemetry/types.js';
-import { TaskTool } from '../tools/task.js';
-import { DEFAULT_QWEN_MODEL } from '../config/models.js';
-
-/**
- * @fileoverview Defines the configuration interfaces for a subagent.
- *
- * These interfaces specify the structure for defining the subagent's prompt,
- * the model parameters, and the execution settings.
- */
-
-interface ExecutionStats {
-  startTimeMs: number;
-  totalDurationMs: number;
-  rounds: number;
-  totalToolCalls: number;
-  successfulToolCalls: number;
-  failedToolCalls: number;
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-  estimatedCost?: number;
-}
-
-/**
- * Manages the runtime context state for the subagent.
- * This class provides a mechanism to store and retrieve key-value pairs
- * that represent the dynamic state and variables accessible to the subagent
- * during its execution.
- */
-export class ContextState {
-  private state: Record<string, unknown> = {};
-
-  /**
-   * Retrieves a value from the context state.
-   *
-   * @param key - The key of the value to retrieve.
-   * @returns The value associated with the key, or undefined if the key is not found.
-   */
-  get(key: string): unknown {
-    return this.state[key];
-  }
-
-  /**
-   * Sets a value in the context state.
-   *
-   * @param key - The key to set the value under.
-   * @param value - The value to set.
-   */
-  set(key: string, value: unknown): void {
-    this.state[key] = value;
-  }
-
-  /**
-   * Retrieves all keys in the context state.
-   *
-   * @returns An array of all keys in the context state.
-   */
-  get_keys(): string[] {
-    return Object.keys(this.state);
-  }
-}
-
-/**
- * Replaces `${...}` placeholders in a template string with values from a context.
- *
- * This function identifies all placeholders in the format `${key}`, validates that
- * each key exists in the provided `ContextState`, and then performs the substitution.
- *
- * @param template The template string containing placeholders.
- * @param context The `ContextState` object providing placeholder values.
- * @returns The populated string with all placeholders replaced.
- * @throws {Error} if any placeholder key is not found in the context.
- */
-function templateString(template: string, context: ContextState): string {
-  const placeholderRegex = /\$\{(\w+)\}/g;
-
-  // First, find all unique keys required by the template.
-  const requiredKeys = new Set(
-    Array.from(template.matchAll(placeholderRegex), (match) => match[1]),
-  );
-
-  // Check if all required keys exist in the context.
-  const contextKeys = new Set(context.get_keys());
-  const missingKeys = Array.from(requiredKeys).filter(
-    (key) => !contextKeys.has(key),
-  );
-
-  if (missingKeys.length > 0) {
-    throw new Error(
-      `Missing context values for the following keys: ${missingKeys.join(
-        ', ',
-      )}`,
-    );
-  }
-
-  // Perform the replacement using a replacer function.
-  return template.replace(placeholderRegex, (_match, key) =>
-    String(context.get(key)),
-  );
-}
-
-/**
- * Represents the scope and execution environment for a subagent.
- * This class orchestrates the subagent's lifecycle, managing its chat interactions,
- * runtime context, and the collection of its outputs.
- */
-export class SubAgentScope {
-  executionStats: ExecutionStats = {
-    startTimeMs: 0,
-    totalDurationMs: 0,
-    rounds: 0,
-    totalToolCalls: 0,
-    successfulToolCalls: 0,
-    failedToolCalls: 0,
-    inputTokens: 0,
-    outputTokens: 0,
-    totalTokens: 0,
-    estimatedCost: 0,
-  };
-  private toolUsage = new Map<
-    string,
-    {
-      count: number;
-      success: number;
-      failure: number;
-      lastError?: string;
-      totalDurationMs?: number;
-      averageDurationMs?: number;
-    }
-  >();
-  private eventEmitter?: SubAgentEventEmitter;
-  private finalText: string = '';
-  private terminateMode: SubagentTerminateMode = SubagentTerminateMode.ERROR;
-  private readonly stats = new SubagentStatistics();
-  private hooks?: SubagentHooks;
-  private readonly subagentId: string;
-
-  /**
-   * Constructs a new SubAgentScope instance.
-   * @param name - The name for the subagent, used for logging and identification.
-   * @param runtimeContext - The shared runtime configuration and services.
-   * @param promptConfig - Configuration for the subagent's prompt and behavior.
-   * @param modelConfig - Configuration for the generative model parameters.
-   * @param runConfig - Configuration for the subagent's execution environment.
-   * @param toolConfig - Optional configuration for tools available to the subagent.
-   */
-  private constructor(
-    readonly name: string,
-    readonly runtimeContext: Config,
-    private readonly promptConfig: PromptConfig,
-    private readonly modelConfig: ModelConfig,
-    private readonly runConfig: RunConfig,
-    private readonly toolConfig?: ToolConfig,
-    eventEmitter?: SubAgentEventEmitter,
-    hooks?: SubagentHooks,
-  ) {
-    const randomPart = Math.random().toString(36).slice(2, 8);
-    this.subagentId = `${this.name}-${randomPart}`;
-    this.eventEmitter = eventEmitter;
-    this.hooks = hooks;
-  }
-
-  /**
-   * Creates and validates a new SubAgentScope instance.
-   * This factory method ensures that all tools provided in the prompt configuration
-   * are valid for non-interactive use before creating the subagent instance.
-   * @param {string} name - The name of the subagent.
-   * @param {Config} runtimeContext - The shared runtime configuration and services.
-   * @param {PromptConfig} promptConfig - Configuration for the subagent's prompt and behavior.
-   * @param {ModelConfig} modelConfig - Configuration for the generative model parameters.
-   * @param {RunConfig} runConfig - Configuration for the subagent's execution environment.
-   * @param {ToolConfig} [toolConfig] - Optional configuration for tools.
-   * @returns {Promise<SubAgentScope>} A promise that resolves to a valid SubAgentScope instance.
-   * @throws {Error} If any tool requires user confirmation.
-   */
-  static async create(
-    name: string,
-    runtimeContext: Config,
-    promptConfig: PromptConfig,
-    modelConfig: ModelConfig,
-    runConfig: RunConfig,
-    toolConfig?: ToolConfig,
-    eventEmitter?: SubAgentEventEmitter,
-    hooks?: SubagentHooks,
-  ): Promise<SubAgentScope> {
-    return new SubAgentScope(
-      name,
-      runtimeContext,
-      promptConfig,
-      modelConfig,
-      runConfig,
-      toolConfig,
-      eventEmitter,
-      hooks,
-    );
-  }
-
-  /**
-   * Runs the subagent in a non-interactive mode.
-   * This method orchestrates the subagent's execution loop, including prompt templating,
-   * tool execution, and termination conditions.
-   * @param {ContextState} context - The current context state containing variables for prompt templating.
-   * @returns {Promise<void>} A promise that resolves when the subagent has completed its execution.
-   */
-  async runNonInteractive(
-    context: ContextState,
-    externalSignal?: AbortSignal,
-  ): Promise<void> {
-    const chat = await this.createChatObject(context);
-
-    if (!chat) {
-      this.terminateMode = SubagentTerminateMode.ERROR;
-      return;
-    }
-
-    // Track the current round's AbortController for external signal propagation
-    let currentRoundAbortController: AbortController | null = null;
-    const onExternalAbort = () => {
-      currentRoundAbortController?.abort();
-    };
-    if (externalSignal) {
-      externalSignal.addEventListener('abort', onExternalAbort);
-    }
-
-    const toolRegistry = this.runtimeContext.getToolRegistry();
-
-    // Prepare the list of tools available to the subagent.
-    // If no explicit toolConfig or it contains "*" or is empty, inherit all tools.
-    const toolsList: FunctionDeclaration[] = [];
-    if (this.toolConfig) {
-      const asStrings = this.toolConfig.tools.filter(
-        (t): t is string => typeof t === 'string',
-      );
-      const hasWildcard = asStrings.includes('*');
-      const onlyInlineDecls = this.toolConfig.tools.filter(
-        (t): t is FunctionDeclaration => typeof t !== 'string',
-      );
-
-      if (hasWildcard || asStrings.length === 0) {
-        toolsList.push(
-          ...toolRegistry
-            .getFunctionDeclarations()
-            .filter((t) => t.name !== TaskTool.Name),
-        );
-      } else {
-        toolsList.push(
-          ...toolRegistry.getFunctionDeclarationsFiltered(asStrings),
-        );
-      }
-      toolsList.push(...onlyInlineDecls);
-    } else {
-      // Inherit all available tools by default when not specified.
-      toolsList.push(
-        ...toolRegistry
-          .getFunctionDeclarations()
-          .filter((t) => t.name !== TaskTool.Name),
-      );
-    }
-
-    const initialTaskText = String(
-      (context.get('task_prompt') as string) ?? 'Get Started!',
-    );
-    let currentMessages: Content[] = [
-      { role: 'user', parts: [{ text: initialTaskText }] },
-    ];
-
-    const startTime = Date.now();
-    this.executionStats.startTimeMs = startTime;
-    this.stats.start(startTime);
-    let turnCounter = 0;
-    try {
-      // Emit start event
-      this.eventEmitter?.emit(SubAgentEventType.START, {
-        subagentId: this.subagentId,
-        name: this.name,
-        model:
-          this.modelConfig.model ||
-          this.runtimeContext.getModel() ||
-          DEFAULT_QWEN_MODEL,
-        tools: (this.toolConfig?.tools || ['*']).map((t) =>
-          typeof t === 'string' ? t : t.name,
-        ),
-        timestamp: Date.now(),
-      } as SubAgentStartEvent);
-
-      // Log telemetry for subagent start
-      const startEvent = new SubagentExecutionEvent(this.name, 'started');
-      logSubagentExecution(this.runtimeContext, startEvent);
-      while (true) {
-        // Create a new AbortController for each round to avoid listener accumulation
-        const roundAbortController = new AbortController();
-        currentRoundAbortController = roundAbortController;
-
-        // If external signal already aborted, cancel immediately
-        if (externalSignal?.aborted) {
-          roundAbortController.abort();
-        }
-
-        // Check termination conditions.
-        if (
-          this.runConfig.max_turns &&
-          turnCounter >= this.runConfig.max_turns
-        ) {
-          this.terminateMode = SubagentTerminateMode.MAX_TURNS;
-          break;
-        }
-        let durationMin = (Date.now() - startTime) / (1000 * 60);
-        if (
-          this.runConfig.max_time_minutes &&
-          durationMin >= this.runConfig.max_time_minutes
-        ) {
-          this.terminateMode = SubagentTerminateMode.TIMEOUT;
-          break;
-        }
-
-        const promptId = `${this.runtimeContext.getSessionId()}#${this.subagentId}#${turnCounter++}`;
-
-        const messageParams = {
-          message: currentMessages[0]?.parts || [],
-          config: {
-            abortSignal: roundAbortController.signal,
-            tools: [{ functionDeclarations: toolsList }],
-          },
-        };
-
-        const roundStreamStart = Date.now();
-        const responseStream = await chat.sendMessageStream(
-          this.modelConfig.model ||
-            this.runtimeContext.getModel() ||
-            DEFAULT_QWEN_MODEL,
-          messageParams,
-          promptId,
-        );
-        this.eventEmitter?.emit(SubAgentEventType.ROUND_START, {
-          subagentId: this.subagentId,
-          round: turnCounter,
-          promptId,
-          timestamp: Date.now(),
-        } as SubAgentRoundEvent);
-
-        const functionCalls: FunctionCall[] = [];
-        let roundText = '';
-        let lastUsage: GenerateContentResponseUsageMetadata | undefined =
-          undefined;
-        let currentResponseId: string | undefined = undefined;
-        for await (const streamEvent of responseStream) {
-          if (roundAbortController.signal.aborted) {
-            this.terminateMode = SubagentTerminateMode.CANCELLED;
-            return;
-          }
-
-          // Handle retry events
-          if (streamEvent.type === 'retry') {
-            continue;
-          }
-
-          // Handle chunk events
-          if (streamEvent.type === 'chunk') {
-            const resp = streamEvent.value;
-            // Track the response ID for tool call correlation
-            if (resp.responseId) {
-              currentResponseId = resp.responseId;
-            }
-            if (resp.functionCalls) functionCalls.push(...resp.functionCalls);
-            const content = resp.candidates?.[0]?.content;
-            const parts = content?.parts || [];
-            for (const p of parts) {
-              const txt = p.text;
-              const isThought = p.thought ?? false;
-              if (txt && !isThought) roundText += txt;
-              if (txt)
-                this.eventEmitter?.emit(SubAgentEventType.STREAM_TEXT, {
-                  subagentId: this.subagentId,
-                  round: turnCounter,
-                  text: txt,
-                  thought: isThought,
-                  timestamp: Date.now(),
-                });
-            }
-            if (resp.usageMetadata) lastUsage = resp.usageMetadata;
-          }
-        }
-        this.executionStats.rounds = turnCounter;
-        this.stats.setRounds(turnCounter);
-
-        durationMin = (Date.now() - startTime) / (1000 * 60);
-        if (
-          this.runConfig.max_time_minutes &&
-          durationMin >= this.runConfig.max_time_minutes
-        ) {
-          this.terminateMode = SubagentTerminateMode.TIMEOUT;
-          break;
-        }
-
-        // Update token usage if available
-        if (lastUsage) {
-          const inTok = Number(lastUsage.promptTokenCount || 0);
-          const outTok = Number(lastUsage.candidatesTokenCount || 0);
-          const thoughtTok = Number(lastUsage.thoughtsTokenCount || 0);
-          const cachedTok = Number(lastUsage.cachedContentTokenCount || 0);
-          if (
-            isFinite(inTok) ||
-            isFinite(outTok) ||
-            isFinite(thoughtTok) ||
-            isFinite(cachedTok)
-          ) {
-            this.stats.recordTokens(
-              isFinite(inTok) ? inTok : 0,
-              isFinite(outTok) ? outTok : 0,
-              isFinite(thoughtTok) ? thoughtTok : 0,
-              isFinite(cachedTok) ? cachedTok : 0,
-            );
-            // mirror legacy fields for compatibility
-            this.executionStats.inputTokens =
-              (this.executionStats.inputTokens || 0) +
-              (isFinite(inTok) ? inTok : 0);
-            this.executionStats.outputTokens =
-              (this.executionStats.outputTokens || 0) +
-              (isFinite(outTok) ? outTok : 0);
-            this.executionStats.totalTokens =
-              (this.executionStats.inputTokens || 0) +
-              (this.executionStats.outputTokens || 0) +
-              (isFinite(thoughtTok) ? thoughtTok : 0) +
-              (isFinite(cachedTok) ? cachedTok : 0);
-            this.executionStats.estimatedCost =
-              (this.executionStats.inputTokens || 0) * 3e-5 +
-              (this.executionStats.outputTokens || 0) * 6e-5;
-          }
-          this.eventEmitter?.emit(SubAgentEventType.USAGE_METADATA, {
-            subagentId: this.subagentId,
-            round: turnCounter,
-            usage: lastUsage,
-            durationMs: Date.now() - roundStreamStart,
-            timestamp: Date.now(),
-          } as SubAgentUsageEvent);
-        }
-
-        if (functionCalls.length > 0) {
-          currentMessages = await this.processFunctionCalls(
-            functionCalls,
-            roundAbortController,
-            promptId,
-            turnCounter,
-            toolsList,
-            currentResponseId,
-          );
-        } else {
-          // No tool calls — treat this as the model's final answer.
-          if (roundText && roundText.trim().length > 0) {
-            this.finalText = roundText.trim();
-            this.terminateMode = SubagentTerminateMode.GOAL;
-            break;
-          }
-          // Otherwise, nudge the model to finalize a result.
-          currentMessages = [
-            {
-              role: 'user',
-              parts: [
-                {
-                  text: 'Please provide the final result now and stop calling tools.',
-                },
-              ],
-            },
-          ];
-        }
-        this.eventEmitter?.emit(SubAgentEventType.ROUND_END, {
-          subagentId: this.subagentId,
-          round: turnCounter,
-          promptId,
-          timestamp: Date.now(),
-        } as SubAgentRoundEvent);
-      }
-    } catch (error) {
-      debugLogger.error('Error during subagent execution:', error);
-      this.terminateMode = SubagentTerminateMode.ERROR;
-      this.eventEmitter?.emit(SubAgentEventType.ERROR, {
-        subagentId: this.subagentId,
-        error: error instanceof Error ? error.message : String(error),
-        timestamp: Date.now(),
-      } as SubAgentErrorEvent);
-
-      throw error;
-    } finally {
-      if (externalSignal) {
-        externalSignal.removeEventListener('abort', onExternalAbort);
-      }
-      // Clear the reference to allow GC
-      currentRoundAbortController = null;
-      this.executionStats.totalDurationMs = Date.now() - startTime;
-      const summary = this.stats.getSummary(Date.now());
-      this.eventEmitter?.emit(SubAgentEventType.FINISH, {
-        subagentId: this.subagentId,
-        terminateReason: this.terminateMode,
-        timestamp: Date.now(),
-        rounds: summary.rounds,
-        totalDurationMs: summary.totalDurationMs,
-        totalToolCalls: summary.totalToolCalls,
-        successfulToolCalls: summary.successfulToolCalls,
-        failedToolCalls: summary.failedToolCalls,
-        inputTokens: summary.inputTokens,
-        outputTokens: summary.outputTokens,
-        totalTokens: summary.totalTokens,
-      } as SubAgentFinishEvent);
-
-      const completionEvent = new SubagentExecutionEvent(
-        this.name,
-        this.terminateMode === SubagentTerminateMode.GOAL
-          ? 'completed'
-          : 'failed',
-        {
-          terminate_reason: this.terminateMode,
-          result: this.finalText,
-          execution_summary: this.stats.formatCompact(
-            'Subagent execution completed',
-          ),
-        },
-      );
-      logSubagentExecution(this.runtimeContext, completionEvent);
-
-      await this.hooks?.onStop?.({
-        subagentId: this.subagentId,
-        name: this.name,
-        terminateReason: this.terminateMode,
-        summary: summary as unknown as Record<string, unknown>,
-        timestamp: Date.now(),
-      });
-    }
-  }
-
-  /**
-   * Processes a list of function calls, executing each one and collecting their responses.
-   * This method iterates through the provided function calls, executes them using the
-   * `executeToolCall` function (or handles `self.emitvalue` internally), and aggregates
-   * their results. It also manages error reporting for failed tool executions.
-   * @param {FunctionCall[]} functionCalls - An array of `FunctionCall` objects to process.
-   * @param {ToolRegistry} toolRegistry - The tool registry to look up and execute tools.
-   * @param {AbortController} abortController - An `AbortController` to signal cancellation of tool executions.
-   * @param {string} responseId - Optional API response ID for correlation with tool calls.
-   * @returns {Promise<Content[]>} A promise that resolves to an array of `Content` parts representing the tool responses,
-   *          which are then used to update the chat history.
-   */
-  private async processFunctionCalls(
-    functionCalls: FunctionCall[],
-    abortController: AbortController,
-    promptId: string,
-    currentRound: number,
-    toolsList: FunctionDeclaration[],
-    responseId?: string,
-  ): Promise<Content[]> {
-    const toolResponseParts: Part[] = [];
-
-    // Build allowed tool names set for filtering
-    const allowedToolNames = new Set(toolsList.map((t) => t.name));
-
-    // Filter unauthorized tool calls before scheduling
-    const authorizedCalls: FunctionCall[] = [];
-    for (const fc of functionCalls) {
-      const callId = fc.id ?? `${fc.name}-${Date.now()}`;
-
-      if (!allowedToolNames.has(fc.name)) {
-        const toolName = String(fc.name);
-        const errorMessage = `Tool "${toolName}" not found. Tools must use the exact names provided.`;
-
-        // Emit TOOL_CALL event for visibility
-        this.eventEmitter?.emit(SubAgentEventType.TOOL_CALL, {
-          subagentId: this.subagentId,
-          round: currentRound,
-          callId,
-          name: toolName,
-          args: fc.args ?? {},
-          description: `Tool "${toolName}" not found`,
-          timestamp: Date.now(),
-        } as SubAgentToolCallEvent);
-
-        // Build function response part (used for both event and LLM)
-        const functionResponsePart = {
-          functionResponse: {
-            id: callId,
-            name: toolName,
-            response: { error: errorMessage },
-          },
-        };
-
-        // Emit TOOL_RESULT event with error (include responseParts for UI rendering)
-        this.eventEmitter?.emit(SubAgentEventType.TOOL_RESULT, {
-          subagentId: this.subagentId,
-          round: currentRound,
-          callId,
-          name: toolName,
-          success: false,
-          error: errorMessage,
-          responseParts: [functionResponsePart],
-          resultDisplay: errorMessage,
-          durationMs: 0,
-          timestamp: Date.now(),
-        } as SubAgentToolResultEvent);
-
-        // Record blocked tool call in stats
-        this.recordToolCallStats(toolName, false, 0, errorMessage);
-
-        // Add function response for LLM
-        toolResponseParts.push(functionResponsePart);
-        continue;
-      }
-      authorizedCalls.push(fc);
-    }
-
-    // Build scheduler
-    const responded = new Set<string>();
-    let resolveBatch: (() => void) | null = null;
-    const scheduler = new CoreToolScheduler({
-      config: this.runtimeContext,
-      outputUpdateHandler: undefined,
-      onAllToolCallsComplete: async (completedCalls) => {
-        for (const call of completedCalls) {
-          const toolName = call.request.name;
-          const duration = call.durationMs ?? 0;
-          const success = call.status === 'success';
-          const errorMessage =
-            call.status === 'error' || call.status === 'cancelled'
-              ? call.response.error?.message
-              : undefined;
-
-          // Record stats
-          this.recordToolCallStats(toolName, success, duration, errorMessage);
-
-          // Emit tool result event
-          this.eventEmitter?.emit(SubAgentEventType.TOOL_RESULT, {
-            subagentId: this.subagentId,
-            round: currentRound,
-            callId: call.request.callId,
-            name: toolName,
-            success,
-            error: errorMessage,
-            responseParts: call.response.responseParts,
-            resultDisplay: call.response.resultDisplay
-              ? typeof call.response.resultDisplay === 'string'
-                ? call.response.resultDisplay
-                : JSON.stringify(call.response.resultDisplay)
-              : undefined,
-            durationMs: duration,
-            timestamp: Date.now(),
-          } as SubAgentToolResultEvent);
-
-          // post-tool hook
-          await this.hooks?.postToolUse?.({
-            subagentId: this.subagentId,
-            name: this.name,
-            toolName,
-            args: call.request.args,
-            success,
-            durationMs: duration,
-            errorMessage,
-            timestamp: Date.now(),
-          });
-
-          // Append response parts
-          const respParts = call.response.responseParts;
-          if (respParts) {
-            const parts = Array.isArray(respParts) ? respParts : [respParts];
-            for (const part of parts) {
-              if (typeof part === 'string') {
-                toolResponseParts.push({ text: part });
-              } else if (part) {
-                toolResponseParts.push(part);
-              }
-            }
-          }
-        }
-        // Signal that this batch is complete (all tools terminal)
-        resolveBatch?.();
-      },
-      onToolCallsUpdate: (calls: ToolCall[]) => {
-        for (const call of calls) {
-          if (call.status !== 'awaiting_approval') continue;
-          const waiting = call as WaitingToolCall;
-
-          // Emit approval request event for UI visibility
-          try {
-            const { confirmationDetails } = waiting;
-            const { onConfirm: _onConfirm, ...rest } = confirmationDetails;
-            this.eventEmitter?.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, {
-              subagentId: this.subagentId,
-              round: currentRound,
-              callId: waiting.request.callId,
-              name: waiting.request.name,
-              description: this.getToolDescription(
-                waiting.request.name,
-                waiting.request.args,
-              ),
-              confirmationDetails: rest,
-              respond: async (
-                outcome: ToolConfirmationOutcome,
-                payload?: Parameters<
-                  ToolCallConfirmationDetails['onConfirm']
-                >[1],
-              ) => {
-                if (responded.has(waiting.request.callId)) return;
-                responded.add(waiting.request.callId);
-                await waiting.confirmationDetails.onConfirm(outcome, payload);
-              },
-              timestamp: Date.now(),
-            });
-          } catch {
-            // ignore UI event emission failures
-          }
-
-          // UI now renders inline confirmation via task tool live output.
-        }
-      },
-      getPreferredEditor: () => undefined,
-      onEditorClose: () => {},
-    });
-
-    // Prepare requests and emit TOOL_CALL events
-    const requests: ToolCallRequestInfo[] = authorizedCalls.map((fc) => {
-      const toolName = String(fc.name || 'unknown');
-      const callId = fc.id ?? `${fc.name}-${Date.now()}`;
-      const args = (fc.args ?? {}) as Record<string, unknown>;
-      const request: ToolCallRequestInfo = {
-        callId,
-        name: toolName,
-        args,
-        isClientInitiated: true,
-        prompt_id: promptId,
-        response_id: responseId,
-      };
-
-      const description = this.getToolDescription(toolName, args);
-      this.eventEmitter?.emit(SubAgentEventType.TOOL_CALL, {
-        subagentId: this.subagentId,
-        round: currentRound,
-        callId,
-        name: toolName,
-        args,
-        description,
-        timestamp: Date.now(),
-      } as SubAgentToolCallEvent);
-
-      // pre-tool hook
-      void this.hooks?.preToolUse?.({
-        subagentId: this.subagentId,
-        name: this.name,
-        toolName,
-        args,
-        timestamp: Date.now(),
-      });
-
-      return request;
-    });
-
-    if (requests.length > 0) {
-      // Create a per-batch completion promise, resolve when onAllToolCallsComplete fires
-      const batchDone = new Promise<void>((resolve) => {
-        resolveBatch = () => {
-          resolve();
-          resolveBatch = null;
-        };
-      });
-      await scheduler.schedule(requests, abortController.signal);
-      await batchDone; // Wait for approvals + execution to finish
-    }
-    // If all tool calls failed, inform the model so it can re-evaluate.
-    if (functionCalls.length > 0 && toolResponseParts.length === 0) {
-      toolResponseParts.push({
-        text: 'All tool calls failed. Please analyze the errors and try an alternative approach.',
-      });
-    }
-
-    return [{ role: 'user', parts: toolResponseParts }];
-  }
-
-  getEventEmitter() {
-    return this.eventEmitter;
-  }
-
-  getStatistics() {
-    const total = this.executionStats.totalToolCalls;
-    const successRate =
-      total > 0 ? (this.executionStats.successfulToolCalls / total) * 100 : 0;
-    return {
-      ...this.executionStats,
-      successRate,
-      toolUsage: Array.from(this.toolUsage.entries()).map(([name, v]) => ({
-        name,
-        ...v,
-      })),
-    };
-  }
-
-  getExecutionSummary(): SubagentStatsSummary {
-    return this.stats.getSummary();
-  }
-
-  getFinalText(): string {
-    return this.finalText;
-  }
-
-  getTerminateMode(): SubagentTerminateMode {
-    return this.terminateMode;
-  }
-
-  private async createChatObject(context: ContextState) {
-    if (!this.promptConfig.systemPrompt && !this.promptConfig.initialMessages) {
-      throw new Error(
-        'PromptConfig must have either `systemPrompt` or `initialMessages` defined.',
-      );
-    }
-    if (this.promptConfig.systemPrompt && this.promptConfig.initialMessages) {
-      throw new Error(
-        'PromptConfig cannot have both `systemPrompt` and `initialMessages` defined.',
-      );
-    }
-
-    const envHistory = await getInitialChatHistory(this.runtimeContext);
-
-    const start_history = [
-      ...envHistory,
-      ...(this.promptConfig.initialMessages ?? []),
-    ];
-
-    const systemInstruction = this.promptConfig.systemPrompt
-      ? this.buildChatSystemPrompt(context)
-      : undefined;
-
-    try {
-      const generationConfig: GenerateContentConfig & {
-        systemInstruction?: string | Content;
-      } = {
-        temperature: this.modelConfig.temp,
-        topP: this.modelConfig.top_p,
-      };
-
-      if (systemInstruction) {
-        generationConfig.systemInstruction = systemInstruction;
-      }
-
-      return new GeminiChat(
-        this.runtimeContext,
-        generationConfig,
-        start_history,
-      );
-    } catch (error) {
-      await reportError(
-        error,
-        'Error initializing chat session.',
-        start_history,
-        'startChat',
-      );
-      // The calling function will handle the undefined return.
-      return undefined;
-    }
-  }
-
-  /**
-   * Safely retrieves the description of a tool by attempting to build it.
-   * Returns an empty string if any error occurs during the process.
-   *
-   * @param toolName The name of the tool to get description for.
-   * @param args The arguments that would be passed to the tool.
-   * @returns The tool description or empty string if error occurs.
-   */
-  private getToolDescription(
-    toolName: string,
-    args: Record<string, unknown>,
-  ): string {
-    try {
-      const toolRegistry = this.runtimeContext.getToolRegistry();
-      const tool = toolRegistry.getTool(toolName);
-      if (!tool) {
-        return '';
-      }
-
-      const toolInstance = tool.build(args);
-      return toolInstance.getDescription() || '';
-    } catch {
-      // Safely ignore all runtime errors and return empty string
-      return '';
-    }
-  }
-
-  /**
-   * Records tool call statistics for both successful and failed tool calls.
-   * This includes updating aggregate stats, per-tool usage, and the statistics service.
-   */
-  private recordToolCallStats(
-    toolName: string,
-    success: boolean,
-    durationMs: number,
-    errorMessage?: string,
-  ): void {
-    // Update aggregate stats
-    this.executionStats.totalToolCalls += 1;
-    if (success) {
-      this.executionStats.successfulToolCalls += 1;
-    } else {
-      this.executionStats.failedToolCalls += 1;
-    }
-
-    // Per-tool usage
-    const tu = this.toolUsage.get(toolName) || {
-      count: 0,
-      success: 0,
-      failure: 0,
-      totalDurationMs: 0,
-      averageDurationMs: 0,
-    };
-    tu.count += 1;
-    if (success) {
-      tu.success += 1;
-    } else {
-      tu.failure += 1;
-      tu.lastError = errorMessage || 'Unknown error';
-    }
-    tu.totalDurationMs = (tu.totalDurationMs || 0) + durationMs;
-    tu.averageDurationMs = tu.count > 0 ? tu.totalDurationMs / tu.count : 0;
-    this.toolUsage.set(toolName, tu);
-
-    // Update statistics service
-    this.stats.recordToolCall(
-      toolName,
-      success,
-      durationMs,
-      this.toolUsage.get(toolName)?.lastError,
-    );
-  }
-
-  private buildChatSystemPrompt(context: ContextState): string {
-    if (!this.promptConfig.systemPrompt) {
-      // This should ideally be caught in createChatObject, but serves as a safeguard.
-      return '';
-    }
-
-    let finalPrompt = templateString(this.promptConfig.systemPrompt, context);
-
-    // Add general non-interactive instructions.
-    finalPrompt += `
-
-Important Rules:
- - You operate in non-interactive mode: do not ask the user questions; proceed with available context.
- - Use tools only when necessary to obtain facts or make changes.
- - When the task is complete, return the final result as a normal model response (not a tool call) and stop.`;
-
-    return finalPrompt;
-  }
-}
diff --git a/packages/core/src/subagents/types.ts b/packages/core/src/subagents/types.ts
index efa73a7e4..e41fe620b 100644
--- a/packages/core/src/subagents/types.ts
+++ b/packages/core/src/subagents/types.ts
@@ -24,7 +24,7 @@ export type SubagentLevel =
 /**
  * Core configuration for a subagent as stored in Markdown files.
  * This interface represents the file-based configuration that gets
- * converted to runtime configuration for SubAgentScope.
+ * converted to runtime configuration for AgentHeadless.
  */
 export interface SubagentConfig {
   /** Unique name identifier for the subagent */
@@ -82,20 +82,20 @@ export interface SubagentConfig {
 }
 
 /**
- * Runtime configuration that converts file-based config to existing SubAgentScope.
+ * Runtime configuration that converts file-based config to AgentHeadless.
  * This interface maps SubagentConfig to the existing runtime interfaces.
  */
 export interface SubagentRuntimeConfig {
-  /** Prompt configuration for SubAgentScope */
+  /** Prompt configuration for AgentHeadless */
   promptConfig: PromptConfig;
 
-  /** Model configuration for SubAgentScope */
+  /** Model configuration for AgentHeadless */
   modelConfig: ModelConfig;
 
-  /** Runtime execution configuration for SubAgentScope */
+  /** Runtime execution configuration for AgentHeadless */
   runConfig: RunConfig;
 
-  /** Optional tool configuration for SubAgentScope */
+  /** Optional tool configuration for AgentHeadless */
   toolConfig?: ToolConfig;
 }
 
@@ -202,6 +202,10 @@ export enum SubagentTerminateMode {
    * Indicates that the subagent's execution was cancelled via an abort signal.
    */
   CANCELLED = 'CANCELLED',
+  /**
+   * Indicates that the subagent was gracefully shut down (e.g., arena/team session ended).
+   */
+  SHUTDOWN = 'SHUTDOWN',
 }
 
 /**
diff --git a/packages/core/src/tools/task.test.ts b/packages/core/src/tools/task.test.ts
index 458b026b6..a8323f71e 100644
--- a/packages/core/src/tools/task.test.ts
+++ b/packages/core/src/tools/task.test.ts
@@ -14,7 +14,10 @@ import {
   type SubagentConfig,
   SubagentTerminateMode,
 } from '../subagents/types.js';
-import { type SubAgentScope, ContextState } from '../subagents/subagent.js';
+import {
+  type AgentHeadless,
+  ContextState,
+} from '../agents/runtime/agent-headless.js';
 import { partToString } from '../utils/partUtils.js';
 
 // Type for accessing protected methods in tests
@@ -34,7 +37,7 @@ type TaskToolWithProtectedMethods = TaskTool & {
 
 // Mock dependencies
 vi.mock('../subagents/subagent-manager.js');
-vi.mock('../subagents/subagent.js');
+vi.mock('../agents/runtime/agent-headless.js');
 
 const MockedSubagentManager = vi.mocked(SubagentManager);
 const MockedContextState = vi.mocked(ContextState);
@@ -80,7 +83,7 @@ describe('TaskTool', () => {
     mockSubagentManager = {
       listSubagents: vi.fn().mockResolvedValue(mockSubagents),
       loadSubagent: vi.fn(),
-      createSubagentScope: vi.fn(),
+      createAgentHeadless: vi.fn(),
       addChangeListener: vi.fn((listener: () => void) => {
         changeListeners.push(listener);
         return () => {
@@ -293,12 +296,12 @@ describe('TaskTool', () => {
   });
 
   describe('TaskToolInvocation', () => {
-    let mockSubagentScope: SubAgentScope;
+    let mockSubagentScope: AgentHeadless;
     let mockContextState: ContextState;
 
     beforeEach(() => {
       mockSubagentScope = {
-        runNonInteractive: vi.fn().mockResolvedValue(undefined),
+        execute: vi.fn().mockResolvedValue(undefined),
         result: 'Task completed successfully',
         terminateMode: SubagentTerminateMode.GOAL,
         getFinalText: vi.fn().mockReturnValue('Task completed successfully'),
@@ -345,7 +348,7 @@ describe('TaskTool', () => {
           failedToolCalls: 0,
         }),
         getTerminateMode: vi.fn().mockReturnValue(SubagentTerminateMode.GOAL),
-      } as unknown as SubAgentScope;
+      } as unknown as AgentHeadless;
 
       mockContextState = {
         set: vi.fn(),
@@ -356,7 +359,7 @@ describe('TaskTool', () => {
       vi.mocked(mockSubagentManager.loadSubagent).mockResolvedValue(
         mockSubagents[0],
       );
-      vi.mocked(mockSubagentManager.createSubagentScope).mockResolvedValue(
+      vi.mocked(mockSubagentManager.createAgentHeadless).mockResolvedValue(
         mockSubagentScope,
       );
     });
@@ -376,12 +379,12 @@ describe('TaskTool', () => {
       expect(mockSubagentManager.loadSubagent).toHaveBeenCalledWith(
         'file-search',
       );
-      expect(mockSubagentManager.createSubagentScope).toHaveBeenCalledWith(
+      expect(mockSubagentManager.createAgentHeadless).toHaveBeenCalledWith(
         mockSubagents[0],
         config,
         expect.any(Object), // eventEmitter parameter
       );
-      expect(mockSubagentScope.runNonInteractive).toHaveBeenCalledWith(
+      expect(mockSubagentScope.execute).toHaveBeenCalledWith(
         mockContextState,
         undefined, // signal parameter (undefined when not provided)
       );
@@ -416,7 +419,7 @@ describe('TaskTool', () => {
     });
 
     it('should handle execution errors gracefully', async () => {
-      vi.mocked(mockSubagentManager.createSubagentScope).mockRejectedValue(
+      vi.mocked(mockSubagentManager.createAgentHeadless).mockRejectedValue(
         new Error('Creation failed'),
       );
 
diff --git a/packages/core/src/tools/task.ts b/packages/core/src/tools/task.ts
index e811dde0d..35aa8af41 100644
--- a/packages/core/src/tools/task.ts
+++ b/packages/core/src/tools/task.ts
@@ -22,18 +22,18 @@ import {
   type SubagentConfig,
   SubagentTerminateMode,
 } from '../subagents/types.js';
-import { ContextState } from '../subagents/subagent.js';
+import { ContextState } from '../agents/runtime/agent-headless.js';
 import {
-  SubAgentEventEmitter,
-  SubAgentEventType,
-} from '../subagents/subagent-events.js';
+  AgentEventEmitter,
+  AgentEventType,
+} from '../agents/runtime/agent-events.js';
 import type {
-  SubAgentToolCallEvent,
-  SubAgentToolResultEvent,
-  SubAgentFinishEvent,
-  SubAgentErrorEvent,
-  SubAgentApprovalRequestEvent,
-} from '../subagents/subagent-events.js';
+  AgentToolCallEvent,
+  AgentToolResultEvent,
+  AgentFinishEvent,
+  AgentErrorEvent,
+  AgentApprovalRequestEvent,
+} from '../agents/runtime/agent-events.js';
 import { createDebugLogger } from '../utils/debugLogger.js';
 
 export interface TaskParams {
@@ -262,7 +262,7 @@ assistant: "I'm going to use the Task tool to launch the with the greeting-respo
 }
 
 class TaskToolInvocation extends BaseToolInvocation<TaskParams, ToolResult> {
-  private readonly _eventEmitter: SubAgentEventEmitter;
+  readonly eventEmitter: AgentEventEmitter = new AgentEventEmitter();
   private currentDisplay: TaskResultDisplay | null = null;
   private currentToolCalls: TaskResultDisplay['toolCalls'] = [];
 
@@ -272,11 +272,6 @@ class TaskToolInvocation extends BaseToolInvocation<TaskParams, ToolResult> {
     params: TaskParams,
   ) {
     super(params);
-    this._eventEmitter = new SubAgentEventEmitter();
-  }
-
-  get eventEmitter(): SubAgentEventEmitter {
-    return this._eventEmitter;
   }
 
   /**
@@ -304,12 +299,12 @@ class TaskToolInvocation extends BaseToolInvocation<TaskParams, ToolResult> {
   private setupEventListeners(
     updateOutput?: (output: ToolResultDisplay) => void,
   ): void {
-    this.eventEmitter.on(SubAgentEventType.START, () => {
+    this.eventEmitter.on(AgentEventType.START, () => {
       this.updateDisplay({ status: 'running' }, updateOutput);
     });
 
-    this.eventEmitter.on(SubAgentEventType.TOOL_CALL, (...args: unknown[]) => {
-      const event = args[0] as SubAgentToolCallEvent;
+    this.eventEmitter.on(AgentEventType.TOOL_CALL, (...args: unknown[]) => {
+      const event = args[0] as AgentToolCallEvent;
       const newToolCall = {
         callId: event.callId,
         name: event.name,
@@ -327,33 +322,30 @@ class TaskToolInvocation extends BaseToolInvocation<TaskParams, ToolResult> {
       );
     });
 
-    this.eventEmitter.on(
-      SubAgentEventType.TOOL_RESULT,
-      (...args: unknown[]) => {
-        const event = args[0] as SubAgentToolResultEvent;
-        const toolCallIndex = this.currentToolCalls!.findIndex(
-          (call) => call.callId === event.callId,
+    this.eventEmitter.on(AgentEventType.TOOL_RESULT, (...args: unknown[]) => {
+      const event = args[0] as AgentToolResultEvent;
+      const toolCallIndex = this.currentToolCalls!.findIndex(
+        (call) => call.callId === event.callId,
+      );
+      if (toolCallIndex >= 0) {
+        this.currentToolCalls![toolCallIndex] = {
+          ...this.currentToolCalls![toolCallIndex],
+          status: event.success ? 'success' : 'failed',
+          error: event.error,
+          responseParts: event.responseParts,
+        };
+
+        this.updateDisplay(
+          {
+            toolCalls: [...this.currentToolCalls!],
+          },
+          updateOutput,
         );
-        if (toolCallIndex >= 0) {
-          this.currentToolCalls![toolCallIndex] = {
-            ...this.currentToolCalls![toolCallIndex],
-            status: event.success ? 'success' : 'failed',
-            error: event.error,
-            responseParts: event.responseParts,
-          };
+      }
+    });
 
-          this.updateDisplay(
-            {
-              toolCalls: [...this.currentToolCalls!],
-            },
-            updateOutput,
-          );
-        }
-      },
-    );
-
-    this.eventEmitter.on(SubAgentEventType.FINISH, (...args: unknown[]) => {
-      const event = args[0] as SubAgentFinishEvent;
+    this.eventEmitter.on(AgentEventType.FINISH, (...args: unknown[]) => {
+      const event = args[0] as AgentFinishEvent;
       this.updateDisplay(
         {
           status: event.terminateReason === 'GOAL' ? 'completed' : 'failed',
@@ -363,8 +355,8 @@ class TaskToolInvocation extends BaseToolInvocation<TaskParams, ToolResult> {
       );
     });
 
-    this.eventEmitter.on(SubAgentEventType.ERROR, (...args: unknown[]) => {
-      const event = args[0] as SubAgentErrorEvent;
+    this.eventEmitter.on(AgentEventType.ERROR, (...args: unknown[]) => {
+      const event = args[0] as AgentErrorEvent;
       this.updateDisplay(
         {
           status: 'failed',
@@ -376,9 +368,9 @@ class TaskToolInvocation extends BaseToolInvocation<TaskParams, ToolResult> {
 
     // Indicate when a tool call is waiting for approval
     this.eventEmitter.on(
-      SubAgentEventType.TOOL_WAITING_APPROVAL,
+      AgentEventType.TOOL_WAITING_APPROVAL,
       (...args: unknown[]) => {
-        const event = args[0] as SubAgentApprovalRequestEvent;
+        const event = args[0] as AgentApprovalRequestEvent;
         const idx = this.currentToolCalls!.findIndex(
           (c) => c.callId === event.callId,
         );
@@ -506,7 +498,7 @@ class TaskToolInvocation extends BaseToolInvocation<TaskParams, ToolResult> {
       if (updateOutput) {
         updateOutput(this.currentDisplay);
       }
-      const subagentScope = await this.subagentManager.createSubagentScope(
+      const subagent = await this.subagentManager.createAgentHeadless(
         subagentConfig,
         this.config,
         { eventEmitter: this.eventEmitter },
@@ -517,13 +509,13 @@ class TaskToolInvocation extends BaseToolInvocation<TaskParams, ToolResult> {
       contextState.set('task_prompt', this.params.prompt);
 
       // Execute the subagent (blocking)
-      await subagentScope.runNonInteractive(contextState, signal);
+      await subagent.execute(contextState, signal);
 
       // Get the results
-      const finalText = subagentScope.getFinalText();
-      const terminateMode = subagentScope.getTerminateMode();
+      const finalText = subagent.getFinalText();
+      const terminateMode = subagent.getTerminateMode();
       const success = terminateMode === SubagentTerminateMode.GOAL;
-      const executionSummary = subagentScope.getExecutionSummary();
+      const executionSummary = subagent.getExecutionSummary();
 
       if (signal?.aborted) {
         this.updateDisplay(
diff --git a/packages/core/src/tools/tools.ts b/packages/core/src/tools/tools.ts
index 96ae53402..b9e4cf62d 100644
--- a/packages/core/src/tools/tools.ts
+++ b/packages/core/src/tools/tools.ts
@@ -9,7 +9,7 @@ import { ToolErrorType } from './tool-error.js';
 import type { DiffUpdateResult } from '../ide/ide-client.js';
 import type { ShellExecutionConfig } from '../services/shellExecutionService.js';
 import { SchemaValidator } from '../utils/schemaValidator.js';
-import { type SubagentStatsSummary } from '../subagents/subagent-statistics.js';
+import { type AgentStatsSummary } from '../agents/runtime/agent-statistics.js';
 import type { AnsiOutput } from '../utils/terminalSerializer.js';
 
 /**
@@ -447,7 +447,7 @@ export interface TaskResultDisplay {
   status: 'running' | 'completed' | 'failed' | 'cancelled';
   terminateReason?: string;
   result?: string;
-  executionSummary?: SubagentStatsSummary;
+  executionSummary?: AgentStatsSummary;
 
   // If the subagent is awaiting approval for a tool call,
   // this contains the confirmation details for inline UI rendering.