diff --git a/internal/runtime/events_subagent.go b/internal/runtime/events_subagent.go
new file mode 100644
index 00000000..094564ab
--- /dev/null
+++ b/internal/runtime/events_subagent.go
@@ -0,0 +1,33 @@
+package runtime
+
+import "neo-code/internal/subagent"
+
+// EventPermissionRequest 为兼容旧事件名保留，语义等同 EventPermissionRequested。
+const EventPermissionRequest EventType = EventPermissionRequested
+
+// EventCompactDone 为兼容旧事件名保留，语义等同 EventCompactApplied。
+const EventCompactDone EventType = EventCompactApplied
+
+// SubAgentEventPayload 描述子代理执行生命周期的事件载荷。
+type SubAgentEventPayload struct {
+	Role       subagent.Role       `json:"role"`
+	TaskID     string              `json:"task_id"`
+	State      subagent.State      `json:"state"`
+	StopReason subagent.StopReason `json:"stop_reason,omitempty"`
+	Step       int                 `json:"step,omitempty"`
+	Delta      string              `json:"delta,omitempty"`
+	Error      string              `json:"error,omitempty"`
+}
+
+const (
+	// EventSubAgentStarted 在子代理任务启动后触发。
+	EventSubAgentStarted EventType = "subagent_started"
+	// EventSubAgentProgress 在子代理执行每一步后触发。
+	EventSubAgentProgress EventType = "subagent_progress"
+	// EventSubAgentCompleted 在子代理成功结束后触发。
+	EventSubAgentCompleted EventType = "subagent_completed"
+	// EventSubAgentFailed 在子代理失败结束后触发。
+	EventSubAgentFailed EventType = "subagent_failed"
+	// EventSubAgentCanceled 在子代理被取消后触发。
+	EventSubAgentCanceled EventType = "subagent_canceled"
+)
diff --git a/internal/runtime/runtime_limits.go b/internal/runtime/runtime_limits.go
new file mode 100644
index 00000000..3cab9213
--- /dev/null
+++ b/internal/runtime/runtime_limits.go
@@ -0,0 +1,4 @@
+package runtime
+
+// defaultMaxLoops 定义兼容旧运行循环逻辑时的默认最大轮数。
+const defaultMaxLoops = 8
diff --git a/internal/runtime/subagent_factory.go b/internal/runtime/subagent_factory.go
new file mode 100644
index 00000000..68662d0b
--- /dev/null
+++ b/internal/runtime/subagent_factory.go
@@ -0,0 +1,97 @@
+package runtime
+
+import (
+	"runtime"
+	"sync"
+
+	"neo-code/internal/subagent"
+)
+
+type subAgentFactoryRegistry struct {
+	mu      sync.RWMutex
+	factory map[*Service]subagent.Factory
+	tracked map[*Service]struct{}
+}
+
+var globalSubAgentFactories = &subAgentFactoryRegistry{
+	factory: make(map[*Service]subagent.Factory),
+	tracked: make(map[*Service]struct{}),
+}
+
+// ensureTracked 为 Service 注册 GC 回调，避免全局注册表持有泄漏。
+func (r *subAgentFactoryRegistry) ensureTracked(s *Service) {
+	if s == nil {
+		return
+	}
+
+	r.mu.Lock()
+	if _, ok := r.tracked[s]; ok {
+		r.mu.Unlock()
+		return
+	}
+	r.tracked[s] = struct{}{}
+	r.mu.Unlock()
+
+	runtime.SetFinalizer(s, func(service *Service) {
+		globalSubAgentFactories.mu.Lock()
+		delete(globalSubAgentFactories.factory, service)
+		delete(globalSubAgentFactories.tracked, service)
+		globalSubAgentFactories.mu.Unlock()
+	})
+}
+
+// set 保存 Service 级工厂实例。
+func (r *subAgentFactoryRegistry) set(s *Service, f subagent.Factory) {
+	if s == nil {
+		return
+	}
+	r.ensureTracked(s)
+
+	r.mu.Lock()
+	r.factory[s] = f
+	r.mu.Unlock()
+}
+
+// get 读取 Service 级工厂实例。
+func (r *subAgentFactoryRegistry) get(s *Service) (subagent.Factory, bool) {
+	if s == nil {
+		return nil, false
+	}
+	r.ensureTracked(s)
+
+	r.mu.RLock()
+	factory, ok := r.factory[s]
+	r.mu.RUnlock()
+	return factory, ok
+}
+
+// defaultSubAgentFactory 返回默认的子代理工厂实例。
+func defaultSubAgentFactory() subagent.Factory {
+	return subagent.NewWorkerFactory(nil)
+}
+
+// SetSubAgentFactory 设置子代理运行时工厂；传入 nil 时回退到默认工厂。
+func (s *Service) SetSubAgentFactory(factory subagent.Factory) {
+	if s == nil {
+		return
+	}
+	if factory == nil {
+		globalSubAgentFactories.set(s, defaultSubAgentFactory())
+		return
+	}
+	globalSubAgentFactories.set(s, factory)
+}
+
+// SubAgentFactory 返回当前 runtime 持有的子代理运行时工厂。
+func (s *Service) SubAgentFactory() subagent.Factory {
+	if s == nil {
+		return defaultSubAgentFactory()
+	}
+	if factory, ok := globalSubAgentFactories.get(s); ok && factory != nil {
+		return factory
+	}
+
+	defaultFactory := defaultSubAgentFactory()
+	globalSubAgentFactories.set(s, defaultFactory)
+	return defaultFactory
+}
diff --git a/internal/runtime/subagent_factory_test.go b/internal/runtime/subagent_factory_test.go
new file mode 100644
index 00000000..9869ba45
--- /dev/null
+++ b/internal/runtime/subagent_factory_test.go
@@ -0,0 +1,54 @@
+package runtime
+
+import (
+	"testing"
+
+	"neo-code/internal/subagent"
+)
+
+type fakeSubAgentFactory struct{}
+
+func (fakeSubAgentFactory) Create(role subagent.Role) (subagent.WorkerRuntime, error) {
+	return subagent.NewWorkerFactory(nil).Create(role)
+}
+
+func TestServiceSubAgentFactoryRegistration(t *testing.T) {
+	t.Parallel()
+
+	svc := NewWithFactory(nil, nil, nil, nil, nil)
+	if svc.SubAgentFactory() == nil {
+		t.Fatalf("expected default sub-agent factory")
+	}
+
+	custom := fakeSubAgentFactory{}
+	svc.SetSubAgentFactory(custom)
+	if svc.SubAgentFactory() == nil {
+		t.Fatalf("expected custom sub-agent factory")
+	}
+
+	svc.SetSubAgentFactory(nil)
+	if svc.SubAgentFactory() == nil {
+		t.Fatalf("expected reset to default sub-agent factory")
+	}
+}
+
+func TestServiceSubAgentFactoryIsolationAcrossInstances(t *testing.T) {
+	t.Parallel()
+
+	svcA := NewWithFactory(nil, nil, nil, nil, nil)
+	svcB := NewWithFactory(nil, nil, nil, nil, nil)
+
+	custom := fakeSubAgentFactory{}
+	svcA.SetSubAgentFactory(custom)
+
+	if svcA.SubAgentFactory() == nil {
+		t.Fatalf("expected service A factory to be set")
+	}
+	if svcB.SubAgentFactory() == nil {
+		t.Fatalf("expected service B default factory")
+	}
+
+	if svcA.SubAgentFactory() == svcB.SubAgentFactory() {
+		t.Fatalf("expected per-service factory isolation")
+	}
+}
diff --git a/internal/runtime/subagent_run.go b/internal/runtime/subagent_run.go
new file mode 100644
index 00000000..31bbd2b6
--- /dev/null
+++ b/internal/runtime/subagent_run.go
@@ -0,0 +1,187 @@
+package runtime
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"neo-code/internal/runtime/controlplane"
+	"neo-code/internal/subagent"
+)
+
+// SubAgentTaskInput 描述一次子代理任务执行请求。
+type SubAgentTaskInput struct {
+	RunID      string
+	SessionID  string
+	Role       subagent.Role
+	Task       subagent.Task
+	Budget     subagent.Budget
+	Capability subagent.Capability
+}
+
+// RunSubAgentTask 使用当前 runtime 注册的工厂执行一条子代理任务。
+func (s *Service) RunSubAgentTask(ctx context.Context, input SubAgentTaskInput) (subagent.Result, error) {
+	if err := ctx.Err(); err != nil {
+		return subagent.Result{}, err
+	}
+	if strings.TrimSpace(input.RunID) == "" {
+		return subagent.Result{}, errors.New("runtime: subagent run id is empty")
+	}
+	if !input.Role.Valid() {
+		return subagent.Result{}, fmt.Errorf("runtime: invalid subagent role %q", input.Role)
+	}
+	if err := input.Task.Validate(); err != nil {
+		return subagent.Result{}, err
+	}
+
+	factory := s.SubAgentFactory()
+	worker, err := factory.Create(input.Role)
+	if err != nil {
+		_ = s.emit(ctx, EventSubAgentFailed, input.RunID, input.SessionID, SubAgentEventPayload{
+			Role:   input.Role,
+			TaskID: input.Task.ID,
+			State:  subagent.StateFailed,
+			Error:  err.Error(),
+		})
+		return subagent.Result{}, err
+	}
+
+	if err := worker.Start(input.Task, input.Budget, input.Capability); err != nil {
+		_ = s.emit(ctx, EventSubAgentFailed, input.RunID, input.SessionID, SubAgentEventPayload{
+			Role:   input.Role,
+			TaskID: input.Task.ID,
+			State:  subagent.StateFailed,
+			Error:  err.Error(),
+		})
+		return subagent.Result{}, err
+	}
+
+	_ = s.emit(ctx, EventSubAgentStarted, input.RunID, input.SessionID, SubAgentEventPayload{
+		Role:   input.Role,
+		TaskID: input.Task.ID,
+		State:  worker.State(),
+	})
+
+	for {
+		stepResult, stepErr := worker.Step(ctx)
+		if stepResult.State == "" {
+			stepResult.State = worker.State()
+		}
+		emitSubAgentProgress(s, input, stepResult, stepErr)
+
+		if stepErr != nil {
+			if errors.Is(stepErr, context.Canceled) || errors.Is(stepErr, context.DeadlineExceeded) {
+				_ = worker.Stop(subagent.StopReasonCanceled)
+				result, resultErr := worker.Result()
+				if resultErr != nil {
+					result = subagent.Result{
+						Role:       input.Role,
+						TaskID:     input.Task.ID,
+						State:      subagent.StateCanceled,
+						StopReason: subagent.StopReasonCanceled,
+						Error:      errorText(stepErr),
+					}
+				}
+				emitSubAgentTerminal(s, ctx, input, result)
+				return result, stepErr
+			}
+
+			result, resultErr := worker.Result()
+			if resultErr != nil {
+				_ = s.emit(ctx, EventSubAgentFailed, input.RunID, input.SessionID, SubAgentEventPayload{
+					Role:   input.Role,
+					TaskID: input.Task.ID,
+					State:  subagent.StateFailed,
+					Error:  stepErr.Error(),
+				})
+				return subagent.Result{}, stepErr
+			}
+			emitSubAgentTerminal(s, ctx, input, result)
+			return result, stepErr
+		}
+
+		if !stepResult.Done {
+			continue
+		}
+
+		result, err := worker.Result()
+		if err != nil {
+			_ = s.emit(ctx, EventSubAgentFailed, input.RunID, input.SessionID, SubAgentEventPayload{
+				Role:   input.Role,
+				TaskID: input.Task.ID,
+				State:  subagent.StateFailed,
+				Error:  err.Error(),
+			})
+			return subagent.Result{}, err
+		}
+		emitSubAgentTerminal(s, ctx, input, result)
+		if result.State == subagent.StateSucceeded {
+			return result, nil
+		}
+		return result, subAgentResultError(result)
+	}
+}
+
+// emitSubAgentProgress 非阻塞发射进度事件，避免慢消费者反压执行路径。
+func emitSubAgentProgress(s *Service, input SubAgentTaskInput, stepResult subagent.StepResult, stepErr error) {
+	payload := SubAgentEventPayload{
+		Role:   input.Role,
+		TaskID: input.Task.ID,
+		State:  stepResult.State,
+		Step:   stepResult.Step,
+		Delta:  stepResult.Delta,
+		Error:  errorText(stepErr),
+	}
+	event := RuntimeEvent{
+		Type:           EventSubAgentProgress,
+		RunID:          input.RunID,
+		SessionID:      input.SessionID,
+		Turn:           turnUnspecified,
+		Timestamp:      time.Now(),
+		PayloadVersion: controlplane.PayloadVersion,
+		Payload:        payload,
+	}
+	select {
+	case s.events <- event:
+	default:
+	}
+}
+
+// emitSubAgentTerminal 按子代理终态发射最终事件。
+func emitSubAgentTerminal(s *Service, ctx context.Context, input SubAgentTaskInput, result subagent.Result) {
+	payload := SubAgentEventPayload{
+		Role:       result.Role,
+		TaskID:     result.TaskID,
+		State:      result.State,
+		StopReason: result.StopReason,
+		Step:       result.StepCount,
+		Error:      strings.TrimSpace(result.Error),
+	}
+
+	switch result.State {
+	case subagent.StateSucceeded:
+		_ = s.emit(ctx, EventSubAgentCompleted, input.RunID, input.SessionID, payload)
+	case subagent.StateCanceled:
+		_ = s.emit(ctx, EventSubAgentCanceled, input.RunID, input.SessionID, payload)
+	default:
+		_ = s.emit(ctx, EventSubAgentFailed, input.RunID, input.SessionID, payload)
+	}
+}
+
+// errorText 将 error 安全转换为事件可用文本。
+func errorText(err error) string {
+	if err == nil {
+		return ""
+	}
+	return strings.TrimSpace(err.Error())
+}
+
+// subAgentResultError 将子代理终态结果转换为可诊断错误，避免空错误文本丢失上下文。
+func subAgentResultError(result subagent.Result) error {
+	if text := strings.TrimSpace(result.Error); text != "" {
+		return errors.New(text)
+	}
+	return fmt.Errorf("subagent ended with state=%s stop_reason=%s", result.State, result.StopReason)
+}
diff --git a/internal/runtime/subagent_run_test.go b/internal/runtime/subagent_run_test.go
new file mode 100644
index 00000000..96f20f81
--- /dev/null
+++ b/internal/runtime/subagent_run_test.go
@@ -0,0 +1,356 @@
+package runtime
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	"neo-code/internal/runtime/controlplane"
+	"neo-code/internal/subagent"
+)
+
+type failingSubAgentFactory struct {
+	err error
+}
+
+func (f failingSubAgentFactory) Create(role subagent.Role) (subagent.WorkerRuntime, error) {
+	return nil, f.err
+}
+
+func TestServiceRunSubAgentTaskSuccess(t *testing.T) {
+	t.Parallel()
+
+	service := NewWithFactory(nil, nil, nil, nil, nil)
+	service.SetSubAgentFactory(subagent.NewWorkerFactory(func(role subagent.Role, policy subagent.RolePolicy) subagent.Engine {
+		return subagent.EngineFunc(func(ctx context.Context, input subagent.StepInput) (subagent.StepOutput, error) {
+			if input.StepIndex == 1 {
+				return subagent.StepOutput{
+					Delta: "step-1",
+					Done:  false,
+				}, nil
+			}
+			return subagent.StepOutput{
+				Delta: "step-2",
+				Done:  true,
+				Output: subagent.Output{
+					Summary:     "task completed",
+					Findings:    []string{"f1"},
+					Patches:     []string{"p1"},
+					Risks:       []string{"r1"},
+					NextActions: []string{"n1"},
+					Artifacts:   []string{"a1"},
+				},
+			}, nil
+		})
+	}))
+
+	result, err := service.RunSubAgentTask(context.Background(), SubAgentTaskInput{
+		RunID:     "sub-run-success",
+		SessionID: "session-1",
+		Role:      subagent.RoleCoder,
+		Task: subagent.Task{
+			ID:   "task-1",
+			Goal: "implement feature",
+		},
+		Budget: subagent.Budget{
+			MaxSteps: 3,
+		},
+	})
+	if err != nil {
+		t.Fatalf("RunSubAgentTask() error = %v", err)
+	}
+	if result.State != subagent.StateSucceeded {
+		t.Fatalf("result state = %q, want %q", result.State, subagent.StateSucceeded)
+	}
+	if result.StepCount != 2 {
+		t.Fatalf("result step count = %d, want 2", result.StepCount)
+	}
+
+	events := collectRuntimeEvents(service.Events())
+	assertEventSequence(t, events, []EventType{
+		EventSubAgentStarted,
+		EventSubAgentProgress,
+		EventSubAgentProgress,
+		EventSubAgentCompleted,
+	})
+	assertEventsRunID(t, events, "sub-run-success")
+	for _, evt := range events {
+		if evt.Type != EventSubAgentProgress {
+			continue
+		}
+		if evt.Timestamp.IsZero() {
+			t.Fatalf("progress event timestamp should be set: %+v", evt)
+		}
+		if evt.PayloadVersion != controlplane.PayloadVersion {
+			t.Fatalf("progress event payload version = %d, want %d", evt.PayloadVersion, controlplane.PayloadVersion)
+		}
+	}
+}
+
+func TestServiceRunSubAgentTaskFailureFlows(t *testing.T) {
+	t.Parallel()
+
+	t.Run("factory create failed", func(t *testing.T) {
+		t.Parallel()
+
+		service := NewWithFactory(nil, nil, nil, nil, nil)
+		service.SetSubAgentFactory(failingSubAgentFactory{err: errors.New("create failed")})
+		_, err := service.RunSubAgentTask(context.Background(), SubAgentTaskInput{
+			RunID: "sub-run-factory-failed",
+			Role:  subagent.RoleResearcher,
+			Task: subagent.Task{
+				ID:   "task-f",
+				Goal: "research",
+			},
+		})
+		if err == nil {
+			t.Fatalf("expected create error")
+		}
+		events := collectRuntimeEvents(service.Events())
+		assertEventSequence(t, events, []EventType{EventSubAgentFailed})
+	})
+
+	t.Run("worker step failed", func(t *testing.T) {
+		t.Parallel()
+
+		service := NewWithFactory(nil, nil, nil, nil, nil)
+		service.SetSubAgentFactory(subagent.NewWorkerFactory(func(role subagent.Role, policy subagent.RolePolicy) subagent.Engine {
+			return subagent.EngineFunc(func(ctx context.Context, input subagent.StepInput) (subagent.StepOutput, error) {
+				return subagent.StepOutput{}, errors.New("step failed")
+			})
+		}))
+		_, err := service.RunSubAgentTask(context.Background(), SubAgentTaskInput{
+			RunID: "sub-run-step-failed",
+			Role:  subagent.RoleReviewer,
+			Task: subagent.Task{
+				ID:   "task-step-f",
+				Goal: "review",
+			},
+		})
+		if err == nil {
+			t.Fatalf("expected step error")
+		}
+		events := collectRuntimeEvents(service.Events())
+		assertEventSequence(t, events, []EventType{
+			EventSubAgentStarted,
+			EventSubAgentProgress,
+			EventSubAgentFailed,
+		})
+	})
+
+	t.Run("context canceled should emit canceled", func(t *testing.T) {
+		t.Parallel()
+
+		service := NewWithFactory(nil, nil, nil, nil, nil)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
+		service.SetSubAgentFactory(subagent.NewWorkerFactory(func(role subagent.Role, policy subagent.RolePolicy) subagent.Engine {
+			return subagent.EngineFunc(func(ctx context.Context, input subagent.StepInput) (subagent.StepOutput, error) {
+				cancel()
+				<-ctx.Done()
+				return subagent.StepOutput{}, ctx.Err()
+			})
+		}))
+
+		result, err := service.RunSubAgentTask(ctx, SubAgentTaskInput{
+			RunID: "sub-run-canceled",
+			Role:  subagent.RoleReviewer,
+			Task: subagent.Task{
+				ID:   "task-cancel",
+				Goal: "review",
+			},
+		})
+		if err == nil {
+			t.Fatalf("expected canceled error")
+		}
+		if !errors.Is(err, context.Canceled) {
+			t.Fatalf("error = %v, want context canceled", err)
+		}
+		if result.State != subagent.StateCanceled {
+			t.Fatalf("result state = %q, want %q", result.State, subagent.StateCanceled)
+		}
+		if result.StopReason != subagent.StopReasonCanceled {
+			t.Fatalf("stop reason = %q, want %q", result.StopReason, subagent.StopReasonCanceled)
+		}
+		events := collectRuntimeEvents(service.Events())
+		assertEventSequence(t, events, []EventType{
+			EventSubAgentStarted,
+			EventSubAgentProgress,
+			EventSubAgentCanceled,
+		})
+	})
+
+	t.Run("worker start failed by disallowed capability", func(t *testing.T) {
+		t.Parallel()
+
+		service := NewWithFactory(nil, nil, nil, nil, nil)
+		_, err := service.RunSubAgentTask(context.Background(), SubAgentTaskInput{
+			RunID: "sub-run-start-failed",
+			Role:  subagent.RoleReviewer,
+			Task: subagent.Task{
+				ID:   "task-start-failed",
+				Goal: "review",
+			},
+			Capability: subagent.Capability{
+				AllowedTools: []string{"bash"},
+			},
+		})
+		if err == nil {
+			t.Fatalf("expected start error")
+		}
+		events := collectRuntimeEvents(service.Events())
+		assertEventSequence(t, events, []EventType{EventSubAgentFailed})
+	})
+
+	t.Run("custom worker failed without explicit error should return fallback", func(t *testing.T) {
+		t.Parallel()
+
+		service := NewWithFactory(nil, nil, nil, nil, nil)
+		service.SetSubAgentFactory(stubSubAgentFactory{
+			create: func(role subagent.Role) (subagent.WorkerRuntime, error) {
+				return &stubSubAgentWorker{
+					result: subagent.Result{
+						Role:       role,
+						TaskID:     "task-fallback-error",
+						State:      subagent.StateFailed,
+						StopReason: subagent.StopReasonError,
+					},
+					stepResult: subagent.StepResult{
+						State: subagent.StateFailed,
+						Done:  true,
+						Step:  1,
+					},
+				}, nil
+			},
+		})
+
+		_, err := service.RunSubAgentTask(context.Background(), SubAgentTaskInput{
+			RunID: "sub-run-fallback-error",
+			Role:  subagent.RoleReviewer,
+			Task: subagent.Task{
+				ID:   "task-fallback-error",
+				Goal: "review",
+			},
+		})
+		if err == nil {
+			t.Fatalf("expected fallback error")
+		}
+		if !strings.Contains(err.Error(), "state=failed") || !strings.Contains(err.Error(), "stop_reason=error") {
+			t.Fatalf("error = %q, want state/stop_reason fallback", err.Error())
+		}
+	})
+}
+
+type stubSubAgentFactory struct {
+	create func(role subagent.Role) (subagent.WorkerRuntime, error)
+}
+
+func (s stubSubAgentFactory) Create(role subagent.Role) (subagent.WorkerRuntime, error) {
+	return s.create(role)
+}
+
+type stubSubAgentWorker struct {
+	startErr    error
+	stepResult  subagent.StepResult
+	stepErr     error
+	result      subagent.Result
+	resultErr   error
+	current     subagent.State
+	stopInvoked bool
+}
+
+func (s *stubSubAgentWorker) Start(task subagent.Task, budget subagent.Budget, capability subagent.Capability) error {
+	if s.startErr != nil {
+		return s.startErr
+	}
+	if s.current == "" {
+		s.current = subagent.StateRunning
+	}
+	s.result.Role = firstNonEmptyRole(s.result.Role, subagent.RoleReviewer)
+	if strings.TrimSpace(s.result.TaskID) == "" {
+		s.result.TaskID = task.ID
+	}
+	return nil
+}
+
+func (s *stubSubAgentWorker) Step(ctx context.Context) (subagent.StepResult, error) {
+	if s.stepResult.State == "" {
+		s.stepResult.State = s.current
+	}
+	if s.stepResult.Done {
+		s.current = s.result.State
+	}
+	return s.stepResult, s.stepErr
+}
+
+func (s *stubSubAgentWorker) Stop(reason subagent.StopReason) error {
+	s.stopInvoked = true
+	s.current = subagent.StateCanceled
+	s.result.State = subagent.StateCanceled
+	s.result.StopReason = reason
+	return nil
+}
+
+func (s *stubSubAgentWorker) Result() (subagent.Result, error) {
+	return s.result, s.resultErr
+}
+
+func (s *stubSubAgentWorker) State() subagent.State {
+	if s.current == "" {
+		return subagent.StateIdle
+	}
+	return s.current
+}
+
+func (s *stubSubAgentWorker) Policy() subagent.RolePolicy {
+	return subagent.RolePolicy{}
+}
+
+func firstNonEmptyRole(role subagent.Role, fallback subagent.Role) subagent.Role {
+	if role != "" {
+		return role
+	}
+	return fallback
+}
+
+func TestServiceRunSubAgentTaskInputValidation(t *testing.T) {
+	t.Parallel()
+
+	service := NewWithFactory(nil, nil, nil, nil, nil)
+	if _, err := service.RunSubAgentTask(context.Background(), SubAgentTaskInput{
+		Role: subagent.RoleCoder,
+		Task: subagent.Task{
+			ID:   "task",
+			Goal: "goal",
+		},
+	}); err == nil {
+		t.Fatalf("expected empty run id error")
+	}
+
+	if _, err := service.RunSubAgentTask(context.Background(), SubAgentTaskInput{
+		RunID: "sub-run-invalid-role",
+		Role:  subagent.Role("x"),
+		Task: subagent.Task{
+			ID:   "task",
+			Goal: "goal",
+		},
+	}); err == nil {
+		t.Fatalf("expected invalid role error")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Nanosecond)
+	defer cancel()
+	time.Sleep(2 * time.Millisecond)
+	if _, err := service.RunSubAgentTask(ctx, SubAgentTaskInput{
+		RunID: "sub-run-timeout",
+		Role:  subagent.RoleCoder,
+		Task: subagent.Task{
+			ID:   "task-timeout",
+			Goal: "goal",
+		},
+	}); err == nil {
+		t.Fatalf("expected context error")
+	}
+}
diff --git a/internal/subagent/engine.go b/internal/subagent/engine.go
new file mode 100644
index 00000000..b8e859d8
--- /dev/null
+++ b/internal/subagent/engine.go
@@ -0,0 +1,34 @@
+package subagent
+
+import (
+	"context"
+	"strings"
+)
+
+// defaultEngine 提供一个可运行的默认单步完成引擎，便于工厂与测试快速装配。
+type defaultEngine struct{}
+
+// RunStep 执行默认单步逻辑并返回结构化结果。
+func (defaultEngine) RunStep(ctx context.Context, input StepInput) (StepOutput, error) {
+	if err := ctx.Err(); err != nil {
+		return StepOutput{}, err
+	}
+
+	summary := strings.TrimSpace(input.Task.ExpectedOutput)
+	if summary == "" {
+		summary = strings.TrimSpace(input.Task.Goal)
+	}
+
+	return StepOutput{
+		Delta: "default engine completed",
+		Done:  true,
+		Output: Output{
+			Summary:     summary,
+			Findings:    []string{"default-engine: no extra findings"},
+			Patches:     []string{"default-engine: no code changes"},
+			Risks:       []string{"default-engine: output generated without external verification"},
+			NextActions: []string{"replace default engine with role-specific implementation if deeper execution is required"},
+			Artifacts:   []string{"default-engine"},
+		},
+	}, nil
+}
diff --git a/internal/subagent/engine_test.go b/internal/subagent/engine_test.go
new file mode 100644
index 00000000..9a11048f
--- /dev/null
+++ b/internal/subagent/engine_test.go
@@ -0,0 +1,89 @@
+package subagent
+
+import (
+	"context"
+	"testing"
+)
+
+func TestDefaultEngineRunStep(t *testing.T) {
+	t.Parallel()
+
+	engine := defaultEngine{}
+
+	t.Run("uses expected output as summary", func(t *testing.T) {
+		t.Parallel()
+
+		out, err := engine.RunStep(context.Background(), StepInput{
+			Task: Task{
+				Goal:           "goal",
+				ExpectedOutput: "expected",
+			},
+		})
+		if err != nil {
+			t.Fatalf("RunStep() error = %v", err)
+		}
+		if !out.Done {
+			t.Fatalf("expected done output")
+		}
+		if out.Output.Summary != "expected" {
+			t.Fatalf("summary = %q, want %q", out.Output.Summary, "expected")
+		}
+		if len(out.Output.Findings) == 0 || len(out.Output.Patches) == 0 || len(out.Output.Risks) == 0 {
+			t.Fatalf("default engine should populate required list sections, got %+v", out.Output)
+		}
+		if len(out.Output.NextActions) == 0 || len(out.Output.Artifacts) == 0 {
+			t.Fatalf("default engine should populate required sections, got %+v", out.Output)
+		}
+	})
+
+	t.Run("falls back to goal", func(t *testing.T) {
+		t.Parallel()
+
+		out, err := engine.RunStep(context.Background(), StepInput{
+			Task: Task{
+				Goal:           "goal-value",
+				ExpectedOutput: " ",
+			},
+		})
+		if err != nil {
+			t.Fatalf("RunStep() error = %v", err)
+		}
+		if out.Output.Summary != "goal-value" {
+			t.Fatalf("summary = %q, want %q", out.Output.Summary, "goal-value")
+		}
+	})
+
+	t.Run("context canceled", func(t *testing.T) {
+		t.Parallel()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel()
+		if _, err := engine.RunStep(ctx, StepInput{Task: Task{Goal: "g"}}); err == nil {
+			t.Fatalf("expected context error")
+		}
+	})
+
+	t.Run("satisfies default role contract", func(t *testing.T) {
+		t.Parallel()
+
+		out, err := engine.RunStep(context.Background(), StepInput{
+			Task: Task{
+				Goal:           "goal",
+				ExpectedOutput: "summary",
+			},
+		})
+		if err != nil {
+			t.Fatalf("RunStep() error = %v", err)
+		}
+
+		for _, role := range []Role{RoleResearcher, RoleCoder, RoleReviewer} {
+			policy, err := DefaultRolePolicy(role)
+			if err != nil {
+				t.Fatalf("DefaultRolePolicy(%q) error = %v", role, err)
+			}
+			if err := validateOutputContract(policy, out.Output); err != nil {
+				t.Fatalf("validateOutputContract(%q) error = %v", role, err)
+			}
+		}
+	})
+}
diff --git a/internal/subagent/factory.go b/internal/subagent/factory.go
new file mode 100644
index 00000000..3b4b19ba
--- /dev/null
+++ b/internal/subagent/factory.go
@@ -0,0 +1,36 @@
+package subagent
+
+import "time"
+
+// EngineBuilder 定义基于角色策略构建执行引擎的工厂函数。
+type EngineBuilder func(role Role, policy RolePolicy) Engine
+
+// WorkerFactory 是默认的 WorkerRuntime 工厂实现。
+type WorkerFactory struct {
+	builder EngineBuilder
+}
+
+// NewWorkerFactory 创建 WorkerFactory；当 builder 为空时使用默认引擎。
+func NewWorkerFactory(builder EngineBuilder) *WorkerFactory {
+	return &WorkerFactory{builder: builder}
+}
+
+// Create 基于角色创建对应策略与执行引擎的 WorkerRuntime。
+func (f *WorkerFactory) Create(role Role) (WorkerRuntime, error) {
+	policy, err := DefaultRolePolicy(role)
+	if err != nil {
+		return nil, err
+	}
+	// 兜底保证默认预算始终可用。
+	policy.DefaultBudget = policy.DefaultBudget.normalize(Budget{
+		MaxSteps: defaultPolicyMaxSteps,
+		Timeout:  defaultPolicyTimeout * time.Second,
+	})
+
+	var engine Engine
+	if f != nil && f.builder != nil {
+		engine = f.builder(role, policy)
+	}
+	return NewWorker(role, policy, engine)
+}
+
diff --git a/internal/subagent/output_contract.go b/internal/subagent/output_contract.go
new file mode 100644
index 00000000..5b7514ea
--- /dev/null
+++ b/internal/subagent/output_contract.go
@@ -0,0 +1,61 @@
+package subagent
+
+import "strings"
+
+var supportedOutputSections = map[string]struct{}{
+	"summary":      {},
+	"findings":     {},
+	"patches":      {},
+	"risks":        {},
+	"next_actions": {},
+	"artifacts":    {},
+}
+
+// validateOutputContract 校验输出结构是否满足角色策略要求。
+func validateOutputContract(policy RolePolicy, output Output) error {
+	out := output.normalize()
+	requiredSections, err := normalizeRequiredSections(policy.RequiredSections)
+	if err != nil {
+		return err
+	}
+	for _, key := range requiredSections {
+		if !hasOutputSectionContent(out, key) {
+			return errorsf("output section %q is required", key)
+		}
+	}
+	return nil
+}
+
+// normalizeRequiredSections 归一化并校验 required section 名称集合。
+func normalizeRequiredSections(sections []string) ([]string, error) {
+	items := dedupeAndTrim(sections)
+	keys := make([]string, 0, len(items))
+	for _, section := range items {
+		key := strings.ToLower(strings.TrimSpace(section))
+		if _, ok := supportedOutputSections[key]; !ok {
+			return nil, errorsf("unsupported required output section %q", section)
+		}
+		keys = append(keys, key)
+	}
+	return keys, nil
+}
+
+// hasOutputSectionContent 判断指定 section 在输出中是否包含有效内容。
+func hasOutputSectionContent(output Output, section string) bool {
+	switch section {
+	case "summary":
+		return strings.TrimSpace(output.Summary) != ""
+	case "findings":
+		return len(output.Findings) > 0
+	case "patches":
+		return len(output.Patches) > 0
+	case "risks":
+		return len(output.Risks) > 0
+	case "next_actions":
+		return len(output.NextActions) > 0
+	case "artifacts":
+		return len(output.Artifacts) > 0
+	default:
+		return false
+	}
+}
diff --git a/internal/subagent/output_contract_test.go b/internal/subagent/output_contract_test.go
new file mode 100644
index 00000000..3971c2d0
--- /dev/null
+++ b/internal/subagent/output_contract_test.go
@@ -0,0 +1,74 @@
+package subagent
+
+import "testing"
+
+func TestValidateOutputContractRequiresAllDeclaredSections(t *testing.T) {
+	t.Parallel()
+
+	policy := RolePolicy{
+		Role:             RoleCoder,
+		SystemPrompt:     "prompt",
+		AllowedTools:     []string{"bash"},
+		RequiredSections: []string{"summary", "findings", "patches", "risks", "next_actions", "artifacts"},
+	}
+
+	full := Output{
+		Summary:     "ok",
+		Findings:    []string{"f"},
+		Patches:     []string{"p"},
+		Risks:       []string{"r"},
+		NextActions: []string{"n"},
+		Artifacts:   []string{"a"},
+	}
+	if err := validateOutputContract(policy, full); err != nil {
+		t.Fatalf("validateOutputContract() error = %v", err)
+	}
+
+	cases := []struct {
+		name   string
+		output Output
+	}{
+		{name: "missing summary", output: Output{
+			Findings: []string{"f"}, Patches: []string{"p"}, Risks: []string{"r"}, NextActions: []string{"n"}, Artifacts: []string{"a"},
+		}},
+		{name: "missing findings", output: Output{
+			Summary: "ok", Patches: []string{"p"}, Risks: []string{"r"}, NextActions: []string{"n"}, Artifacts: []string{"a"},
+		}},
+		{name: "missing patches", output: Output{
+			Summary: "ok", Findings: []string{"f"}, Risks: []string{"r"}, NextActions: []string{"n"}, Artifacts: []string{"a"},
+		}},
+		{name: "missing risks", output: Output{
+			Summary: "ok", Findings: []string{"f"}, Patches: []string{"p"}, NextActions: []string{"n"}, Artifacts: []string{"a"},
+		}},
+		{name: "missing next actions", output: Output{
+			Summary: "ok", Findings: []string{"f"}, Patches: []string{"p"}, Risks: []string{"r"}, Artifacts: []string{"a"},
+		}},
+		{name: "missing artifacts", output: Output{
+			Summary: "ok", Findings: []string{"f"}, Patches: []string{"p"}, Risks: []string{"r"}, NextActions: []string{"n"},
+		}},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			if err := validateOutputContract(policy, tc.output); err == nil {
+				t.Fatalf("expected contract validation error")
+			}
+		})
+	}
+}
+
+func TestValidateOutputContractUnsupportedSection(t *testing.T) {
+	t.Parallel()
+
+	policy := RolePolicy{
+		Role:             RoleResearcher,
+		SystemPrompt:     "prompt",
+		AllowedTools:     []string{"filesystem_grep"},
+		RequiredSections: []string{"summary", "x"},
+	}
+	if err := validateOutputContract(policy, Output{Summary: "ok"}); err == nil {
+		t.Fatalf("expected unsupported section error")
+	}
+}
diff --git a/internal/subagent/policy.go b/internal/subagent/policy.go
new file mode 100644
index 00000000..12c81544
--- /dev/null
+++ b/internal/subagent/policy.go
@@ -0,0 +1,86 @@
+package subagent
+
+import (
+	"strings"
+	"time"
+)
+
+const (
+	defaultPolicyMaxSteps = 6
+	defaultPolicyTimeout  = 30
+)
+
+// RolePolicy 定义不同角色的执行策略。
+type RolePolicy struct {
+	Role             Role
+	SystemPrompt     string
+	AllowedTools     []string
+	DefaultBudget    Budget
+	RequiredSections []string
+}
+
+// Validate 校验角色策略是否合法。
+func (p RolePolicy) Validate() error {
+	if !p.Role.Valid() {
+		return errorsf("invalid policy role %q", p.Role)
+	}
+	if strings.TrimSpace(p.SystemPrompt) == "" {
+		return errorsf("role policy prompt is required")
+	}
+	if len(dedupeAndTrim(p.AllowedTools)) == 0 {
+		return errorsf("role policy allowed tools is empty")
+	}
+	if len(dedupeAndTrim(p.RequiredSections)) == 0 {
+		return errorsf("role policy required sections is empty")
+	}
+	if _, err := normalizeRequiredSections(p.RequiredSections); err != nil {
+		return err
+	}
+	return nil
+}
+
+// DefaultRolePolicy 返回内置角色策略。
+func DefaultRolePolicy(role Role) (RolePolicy, error) {
+	if !role.Valid() {
+		return RolePolicy{}, errorsf("unsupported role %q", role)
+	}
+
+	policy := RolePolicy{
+		Role: role,
+		DefaultBudget: Budget{
+			MaxSteps: defaultPolicyMaxSteps,
+			Timeout:  defaultPolicyTimeout * time.Second,
+		},
+		RequiredSections: []string{
+			"summary",
+			"findings",
+			"patches",
+			"risks",
+			"next_actions",
+			"artifacts",
+		},
+	}
+
+	switch role {
+	case RoleResearcher:
+		policy.SystemPrompt = "你是研究型子代理，负责检索证据并形成结论。"
+		policy.AllowedTools = []string{"filesystem_read_file", "filesystem_glob", "filesystem_grep", "webfetch"}
+	case RoleCoder:
+		policy.SystemPrompt = "你是实现型子代理，负责修改代码并给出验证结果。"
+		policy.AllowedTools = []string{
+			"filesystem_read_file",
+			"filesystem_write_file",
+			"filesystem_edit",
+			"filesystem_glob",
+			"filesystem_grep",
+			"bash",
+		}
+	case RoleReviewer:
+		policy.SystemPrompt = "你是审查型子代理，负责识别缺陷、风险与测试缺口。"
+		policy.AllowedTools = []string{"filesystem_read_file", "filesystem_glob", "filesystem_grep"}
+	}
+
+	policy.AllowedTools = dedupeAndTrim(policy.AllowedTools)
+	policy.RequiredSections = dedupeAndTrim(policy.RequiredSections)
+	return policy, nil
+}
diff --git a/internal/subagent/policy_test.go b/internal/subagent/policy_test.go
new file mode 100644
index 00000000..08721d37
--- /dev/null
+++ b/internal/subagent/policy_test.go
@@ -0,0 +1,124 @@
+package subagent
+
+import "testing"
+
+func TestDefaultRolePolicy(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		role Role
+	}{
+		{name: "researcher", role: RoleResearcher},
+		{name: "coder", role: RoleCoder},
+		{name: "reviewer", role: RoleReviewer},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			policy, err := DefaultRolePolicy(tt.role)
+			if err != nil {
+				t.Fatalf("DefaultRolePolicy() error = %v", err)
+			}
+			if policy.Role != tt.role {
+				t.Fatalf("policy role = %q, want %q", policy.Role, tt.role)
+			}
+			if policy.DefaultBudget.MaxSteps <= 0 {
+				t.Fatalf("invalid max steps: %d", policy.DefaultBudget.MaxSteps)
+			}
+			if len(policy.AllowedTools) == 0 {
+				t.Fatalf("expected non-empty allowed tools")
+			}
+			if len(policy.RequiredSections) == 0 {
+				t.Fatalf("expected non-empty required sections")
+			}
+			if err := policy.Validate(); err != nil {
+				t.Fatalf("policy.Validate() error = %v", err)
+			}
+		})
+	}
+}
+
+func TestDefaultRolePolicyInvalidRole(t *testing.T) {
+	t.Parallel()
+
+	if _, err := DefaultRolePolicy(Role("unknown")); err == nil {
+		t.Fatalf("expected invalid role error")
+	}
+}
+
+func TestRolePolicyValidate(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		policy  RolePolicy
+		wantErr bool
+	}{
+		{
+			name: "valid",
+			policy: RolePolicy{
+				Role:             RoleResearcher,
+				SystemPrompt:     "prompt",
+				AllowedTools:     []string{"filesystem_grep"},
+				RequiredSections: []string{"summary"},
+			},
+		},
+		{
+			name: "empty prompt",
+			policy: RolePolicy{
+				Role:             RoleResearcher,
+				AllowedTools:     []string{"filesystem_grep"},
+				RequiredSections: []string{"summary"},
+			},
+			wantErr: true,
+		},
+		{
+			name: "empty tools",
+			policy: RolePolicy{
+				Role:             RoleResearcher,
+				SystemPrompt:     "prompt",
+				RequiredSections: []string{"summary"},
+			},
+			wantErr: true,
+		},
+		{
+			name: "invalid role",
+			policy: RolePolicy{
+				Role:             Role("x"),
+				SystemPrompt:     "prompt",
+				AllowedTools:     []string{"filesystem_grep"},
+				RequiredSections: []string{"summary"},
+			},
+			wantErr: true,
+		},
+		{
+			name: "unsupported required section",
+			policy: RolePolicy{
+				Role:             RoleResearcher,
+				SystemPrompt:     "prompt",
+				AllowedTools:     []string{"filesystem_grep"},
+				RequiredSections: []string{"unknown_section"},
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := tt.policy.Validate()
+			if tt.wantErr && err == nil {
+				t.Fatalf("expected error")
+			}
+			if !tt.wantErr && err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+		})
+	}
+}
diff --git a/internal/subagent/types.go b/internal/subagent/types.go
new file mode 100644
index 00000000..9e3ba823
--- /dev/null
+++ b/internal/subagent/types.go
@@ -0,0 +1,224 @@
+package subagent
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+)
+
+// Role 表示子代理的执行角色。
+type Role string
+
+const (
+	// RoleResearcher 用于检索与分析任务。
+	RoleResearcher Role = "researcher"
+	// RoleCoder 用于实现与修复任务。
+	RoleCoder Role = "coder"
+	// RoleReviewer 用于审查与验收任务。
+	RoleReviewer Role = "reviewer"
+)
+
+// Valid 判断角色是否受支持。
+func (r Role) Valid() bool {
+	switch r {
+	case RoleResearcher, RoleCoder, RoleReviewer:
+		return true
+	default:
+		return false
+	}
+}
+
+// Budget 描述子代理执行预算。
+type Budget struct {
+	MaxSteps int
+	Timeout  time.Duration
+}
+
+// normalize 归一化预算并应用默认值。
+func (b Budget) normalize(defaults Budget) Budget {
+	out := b
+	if out.MaxSteps <= 0 {
+		out.MaxSteps = defaults.MaxSteps
+	}
+	if out.MaxSteps <= 0 {
+		out.MaxSteps = 6
+	}
+	if out.Timeout <= 0 {
+		out.Timeout = defaults.Timeout
+	}
+	if out.Timeout <= 0 {
+		out.Timeout = 30 * time.Second
+	}
+	return out
+}
+
+// Capability 描述子代理运行时可用能力边界。
+type Capability struct {
+	AllowedTools []string
+	AllowedPaths []string
+}
+
+// normalize 归一化能力列表并去重。
+func (c Capability) normalize() Capability {
+	return Capability{
+		AllowedTools: dedupeAndTrim(c.AllowedTools),
+		AllowedPaths: dedupeAndTrim(c.AllowedPaths),
+	}
+}
+
+// Task 表示单个子代理任务输入。
+type Task struct {
+	ID             string
+	Goal           string
+	ExpectedOutput string
+	Workspace      string
+}
+
+// Validate 校验任务输入是否合法。
+func (t Task) Validate() error {
+	if strings.TrimSpace(t.ID) == "" {
+		return errorsf("task id is required")
+	}
+	if strings.TrimSpace(t.Goal) == "" {
+		return errorsf("task goal is required")
+	}
+	return nil
+}
+
+// StopReason 表示子代理终止原因。
+type StopReason string
+
+const (
+	// StopReasonCompleted 表示正常完成。
+	StopReasonCompleted StopReason = "completed"
+	// StopReasonCanceled 表示被取消。
+	StopReasonCanceled StopReason = "canceled"
+	// StopReasonTimeout 表示执行超时。
+	StopReasonTimeout StopReason = "timeout"
+	// StopReasonMaxSteps 表示达到步数上限。
+	StopReasonMaxSteps StopReason = "max_steps"
+	// StopReasonError 表示执行错误。
+	StopReasonError StopReason = "error"
+)
+
+// State 表示子代理生命周期状态。
+type State string
+
+const (
+	// StateIdle 表示尚未启动。
+	StateIdle State = "idle"
+	// StateRunning 表示执行中。
+	StateRunning State = "running"
+	// StateSucceeded 表示执行成功结束。
+	StateSucceeded State = "succeeded"
+	// StateFailed 表示执行失败结束。
+	StateFailed State = "failed"
+	// StateCanceled 表示被取消结束。
+	StateCanceled State = "canceled"
+)
+
+// Terminal 判断当前状态是否为终态。
+func (s State) Terminal() bool {
+	switch s {
+	case StateSucceeded, StateFailed, StateCanceled:
+		return true
+	default:
+		return false
+	}
+}
+
+// Output 定义子代理标准结构化输出。
+type Output struct {
+	Summary     string
+	Findings    []string
+	Patches     []string
+	Risks       []string
+	NextActions []string
+	Artifacts   []string
+}
+
+// normalize 归一化输出，避免重复与空项。
+func (o Output) normalize() Output {
+	o.Summary = strings.TrimSpace(o.Summary)
+	o.Findings = dedupeAndTrim(o.Findings)
+	o.Patches = dedupeAndTrim(o.Patches)
+	o.Risks = dedupeAndTrim(o.Risks)
+	o.NextActions = dedupeAndTrim(o.NextActions)
+	o.Artifacts = dedupeAndTrim(o.Artifacts)
+	return o
+}
+
+// StepInput 表示单步执行输入。
+type StepInput struct {
+	Role       Role
+	Policy     RolePolicy
+	Task       Task
+	Budget     Budget
+	Capability Capability
+	StepIndex  int
+	Trace      []string
+}
+
+// StepOutput 表示单步执行输出。
+type StepOutput struct {
+	Delta  string
+	Done   bool
+	Output Output
+}
+
+// StepResult 表示一次 Step 的可观测结果。
+type StepResult struct {
+	State State
+	Done  bool
+	Step  int
+	Delta string
+}
+
+// Result 描述子代理完成后的结构化结果。
+type Result struct {
+	Role       Role
+	TaskID     string
+	State      State
+	StopReason StopReason
+	StartedAt  time.Time
+	EndedAt    time.Time
+	StepCount  int
+	Budget     Budget
+	Capability Capability
+	Output     Output
+	Error      string
+}
+
+// Engine 定义 WorkerRuntime 的单步执行引擎。
+type Engine interface {
+	RunStep(ctx context.Context, input StepInput) (StepOutput, error)
+}
+
+// EngineFunc 允许用函数实现 Engine。
+type EngineFunc func(ctx context.Context, input StepInput) (StepOutput, error)
+
+// RunStep 执行函数式引擎逻辑。
+func (f EngineFunc) RunStep(ctx context.Context, input StepInput) (StepOutput, error) {
+	return f(ctx, input)
+}
+
+// WorkerRuntime 定义子代理执行生命周期接口。
+type WorkerRuntime interface {
+	Start(task Task, budget Budget, capability Capability) error
+	Step(ctx context.Context) (StepResult, error)
+	Stop(reason StopReason) error
+	Result() (Result, error)
+	State() State
+	Policy() RolePolicy
+}
+
+// Factory 定义 runtime 侧创建 WorkerRuntime 的入口。
+type Factory interface {
+	Create(role Role) (WorkerRuntime, error)
+}
+
+// errorsf 统一组装 subagent 模块错误前缀。
+func errorsf(format string, args ...any) error {
+	return fmt.Errorf("subagent: "+format, args...)
+}
diff --git a/internal/subagent/util.go b/internal/subagent/util.go
new file mode 100644
index 00000000..a87acc25
--- /dev/null
+++ b/internal/subagent/util.go
@@ -0,0 +1,28 @@
+package subagent
+
+import "strings"
+
+// dedupeAndTrim 对字符串切片做去空白、去重并保持原顺序。
+func dedupeAndTrim(items []string) []string {
+	if len(items) == 0 {
+		return nil
+	}
+	result := make([]string, 0, len(items))
+	seen := make(map[string]struct{}, len(items))
+	for _, raw := range items {
+		item := strings.TrimSpace(raw)
+		if item == "" {
+			continue
+		}
+		key := strings.ToLower(item)
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		result = append(result, item)
+	}
+	if len(result) == 0 {
+		return nil
+	}
+	return result
+}
diff --git a/internal/subagent/worker.go b/internal/subagent/worker.go
new file mode 100644
index 00000000..18e9cf17
--- /dev/null
+++ b/internal/subagent/worker.go
@@ -0,0 +1,327 @@
+package subagent
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"sync"
+	"time"
+)
+
+// worker 是 WorkerRuntime 的默认实现，负责封装单任务生命周期。
+type worker struct {
+	mu         sync.RWMutex
+	role       Role
+	policy     RolePolicy
+	engine     Engine
+	state      State
+	task       Task
+	budget     Budget
+	capability Capability
+	stepCount  int
+	trace      []string
+	startedAt  time.Time
+	endedAt    time.Time
+	stopReason StopReason
+	output     Output
+	lastErr    string
+}
+
+const traceWindowSize = 16
+
+// NewWorker 根据角色、策略与引擎创建一个 WorkerRuntime 实例。
+func NewWorker(role Role, policy RolePolicy, engine Engine) (WorkerRuntime, error) {
+	if !role.Valid() {
+		return nil, errorsf("invalid role %q", role)
+	}
+	if policy.Role == "" {
+		policy.Role = role
+	}
+	if policy.Role != role {
+		return nil, errorsf("policy role %q does not match worker role %q", policy.Role, role)
+	}
+	if err := policy.Validate(); err != nil {
+		return nil, err
+	}
+	if engine == nil {
+		engine = defaultEngine{}
+	}
+
+	return &worker{
+		role:   role,
+		policy: policy,
+		engine: engine,
+		state:  StateIdle,
+	}, nil
+}
+
+// Start 初始化任务执行上下文并进入运行态。
+func (w *worker) Start(task Task, budget Budget, capability Capability) error {
+	if w == nil {
+		return errors.New("subagent: worker is nil")
+	}
+	if err := task.Validate(); err != nil {
+		return err
+	}
+
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.state != StateIdle {
+		return errorsf("worker already started")
+	}
+
+	w.task = task
+	w.budget = budget.normalize(w.policy.DefaultBudget)
+	effectiveCapability, err := bindCapabilityToPolicy(capability.normalize(), w.policy)
+	if err != nil {
+		return err
+	}
+	w.capability = effectiveCapability
+	w.trace = nil
+	w.stepCount = 0
+	w.output = Output{}
+	w.lastErr = ""
+	w.stopReason = ""
+	w.startedAt = time.Now()
+	w.endedAt = time.Time{}
+	w.state = StateRunning
+	return nil
+}
+
+// Step 执行一次引擎步骤，并在满足终止条件时更新终态结果。
+func (w *worker) Step(ctx context.Context) (StepResult, error) {
+	if w == nil {
+		return StepResult{}, errors.New("subagent: worker is nil")
+	}
+	if err := ctx.Err(); err != nil {
+		return StepResult{}, err
+	}
+
+	w.mu.Lock()
+	if w.state != StateRunning {
+		state := w.state
+		w.mu.Unlock()
+		return StepResult{}, errorsf("worker is not running, current state=%s", state)
+	}
+	if w.budget.Timeout > 0 && time.Since(w.startedAt) >= w.budget.Timeout {
+		result := w.finishLocked(StateFailed, StopReasonTimeout, Output{}, errorsf("worker timeout"))
+		w.mu.Unlock()
+		return StepResult{State: result.State, Done: true, Step: result.StepCount}, nil
+	}
+	if w.stepCount >= w.budget.MaxSteps {
+		result := w.finishLocked(StateFailed, StopReasonMaxSteps, Output{}, errorsf("worker reached max steps"))
+		w.mu.Unlock()
+		return StepResult{State: result.State, Done: true, Step: result.StepCount}, nil
+	}
+
+	input := StepInput{
+		Role:       w.role,
+		Policy:     w.policy,
+		Task:       w.task,
+		Budget:     w.budget,
+		Capability: w.capability,
+		StepIndex:  w.stepCount + 1,
+		Trace:      cloneRecentTrace(w.trace, traceWindowSize),
+	}
+	w.mu.Unlock()
+
+	stepOutput, err := w.engine.RunStep(ctx, input)
+	if err != nil {
+		w.mu.Lock()
+		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+			result := w.finishLocked(StateCanceled, StopReasonCanceled, Output{}, nil)
+			w.mu.Unlock()
+			return StepResult{State: result.State, Done: true, Step: result.StepCount}, err
+		}
+		result := w.finishLocked(StateFailed, StopReasonError, Output{}, err)
+		w.mu.Unlock()
+		return StepResult{State: result.State, Done: true, Step: result.StepCount}, err
+	}
+
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.state != StateRunning {
+		return StepResult{}, errorsf("worker is not running, current state=%s", w.state)
+	}
+
+	w.stepCount++
+	delta := strings.TrimSpace(stepOutput.Delta)
+	if delta != "" {
+		w.trace = appendTraceBounded(w.trace, delta, traceWindowSize)
+	}
+
+	if stepOutput.Done {
+		if err := validateOutputContract(w.policy, stepOutput.Output); err != nil {
+			result := w.finishLocked(StateFailed, StopReasonError, Output{}, err)
+			return StepResult{State: result.State, Done: true, Step: result.StepCount, Delta: delta}, err
+		}
+		result := w.finishLocked(StateSucceeded, StopReasonCompleted, stepOutput.Output, nil)
+		return StepResult{State: result.State, Done: true, Step: result.StepCount, Delta: delta}, nil
+	}
+
+	if w.stepCount >= w.budget.MaxSteps {
+		result := w.finishLocked(StateFailed, StopReasonMaxSteps, Output{}, errorsf("worker reached max steps"))
+		return StepResult{State: result.State, Done: true, Step: result.StepCount, Delta: delta}, nil
+	}
+
+	return StepResult{
+		State: StateRunning,
+		Done:  false,
+		Step:  w.stepCount,
+		Delta: delta,
+	}, nil
+}
+
+// bindCapabilityToPolicy 将 capability 约束在角色策略允许的工具集合内。
+func bindCapabilityToPolicy(capability Capability, policy RolePolicy) (Capability, error) {
+	if len(capability.AllowedPaths) > 0 {
+		return Capability{}, errorsf("capability allowed paths is not supported yet")
+	}
+
+	allowedPolicyTools := dedupeAndTrim(policy.AllowedTools)
+	allowedSet := make(map[string]struct{}, len(allowedPolicyTools))
+	for _, tool := range allowedPolicyTools {
+		allowedSet[strings.ToLower(strings.TrimSpace(tool))] = struct{}{}
+	}
+
+	if len(capability.AllowedTools) == 0 {
+		capability.AllowedTools = append([]string(nil), allowedPolicyTools...)
+		return capability, nil
+	}
+
+	effective := make([]string, 0, len(capability.AllowedTools))
+	disallowed := make([]string, 0)
+	for _, tool := range capability.AllowedTools {
+		normalized := strings.ToLower(strings.TrimSpace(tool))
+		if _, ok := allowedSet[normalized]; !ok {
+			disallowed = append(disallowed, tool)
+			continue
+		}
+		effective = append(effective, tool)
+	}
+	if len(disallowed) > 0 {
+		return Capability{}, errorsf("capability contains disallowed tools: %s", strings.Join(disallowed, ", "))
+	}
+	capability.AllowedTools = effective
+	return capability, nil
+}
+
+// appendTraceBounded 将新增 trace 追加到切片尾部，并保证内部存储长度不超过上限。
+func appendTraceBounded(trace []string, delta string, limit int) []string {
+	trace = append(trace, delta)
+	if limit <= 0 || len(trace) <= limit {
+		return trace
+	}
+	start := len(trace) - limit
+	copy(trace, trace[start:])
+	return trace[:limit]
+}
+
+// cloneRecentTrace 复制最近 limit 条 trace，避免每步复制完整历史导致复杂度放大。
+func cloneRecentTrace(trace []string, limit int) []string {
+	if len(trace) == 0 {
+		return nil
+	}
+	if limit <= 0 || len(trace) <= limit {
+		return append([]string(nil), trace...)
+	}
+	start := len(trace) - limit
+	return append([]string(nil), trace[start:]...)
+}
+
+// Stop 主动终止运行中的 worker，并按终止原因映射最终状态。
+func (w *worker) Stop(reason StopReason) error {
+	if w == nil {
+		return errors.New("subagent: worker is nil")
+	}
+	if strings.TrimSpace(string(reason)) == "" {
+		return errorsf("stop reason is required")
+	}
+
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.state != StateRunning {
+		if w.state.Terminal() {
+			return nil
+		}
+		return errorsf("worker is not running, current state=%s", w.state)
+	}
+
+	switch reason {
+	case StopReasonCompleted:
+		if err := validateOutputContract(w.policy, w.output); err != nil {
+			return err
+		}
+		w.finishLocked(StateSucceeded, reason, w.output, nil)
+	case StopReasonCanceled:
+		w.finishLocked(StateCanceled, reason, w.output, nil)
+	case StopReasonTimeout, StopReasonMaxSteps, StopReasonError:
+		w.finishLocked(StateFailed, reason, w.output, nil)
+	default:
+		return errorsf("unsupported stop reason %q", reason)
+	}
+	return nil
+}
+
+// Result 返回 worker 的最终结构化结果。
+func (w *worker) Result() (Result, error) {
+	if w == nil {
+		return Result{}, errors.New("subagent: worker is nil")
+	}
+
+	w.mu.RLock()
+	defer w.mu.RUnlock()
+	if !w.state.Terminal() {
+		return Result{}, errorsf("worker is not finished")
+	}
+	return w.snapshotLocked(), nil
+}
+
+// State 返回当前 worker 生命周期状态。
+func (w *worker) State() State {
+	if w == nil {
+		return StateIdle
+	}
+	w.mu.RLock()
+	defer w.mu.RUnlock()
+	return w.state
+}
+
+// Policy 返回当前 worker 角色策略副本。
+func (w *worker) Policy() RolePolicy {
+	if w == nil {
+		return RolePolicy{}
+	}
+	w.mu.RLock()
+	defer w.mu.RUnlock()
+	return w.policy
+}
+
+// finishLocked 在持有写锁时将 worker 切换为终态并返回结果快照。
+func (w *worker) finishLocked(state State, reason StopReason, output Output, err error) Result {
+	w.state = state
+	w.stopReason = reason
+	w.endedAt = time.Now()
+	w.output = output.normalize()
+	if err != nil {
+		w.lastErr = err.Error()
+	}
+	return w.snapshotLocked()
+}
+
+// snapshotLocked 在持有读锁或写锁时构造稳定结果快照。
+func (w *worker) snapshotLocked() Result {
+	return Result{
+		Role:       w.role,
+		TaskID:     w.task.ID,
+		State:      w.state,
+		StopReason: w.stopReason,
+		StartedAt:  w.startedAt,
+		EndedAt:    w.endedAt,
+		StepCount:  w.stepCount,
+		Budget:     w.budget,
+		Capability: w.capability,
+		Output:     w.output,
+		Error:      w.lastErr,
+	}
+}
diff --git a/internal/subagent/worker_test.go b/internal/subagent/worker_test.go
new file mode 100644
index 00000000..532e4c76
--- /dev/null
+++ b/internal/subagent/worker_test.go
@@ -0,0 +1,437 @@
+package subagent
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+)
+
+func TestWorkerLifecycleCompleted(t *testing.T) {
+	t.Parallel()
+
+	policy, err := DefaultRolePolicy(RoleCoder)
+	if err != nil {
+		t.Fatalf("DefaultRolePolicy() error = %v", err)
+	}
+
+	w, err := NewWorker(RoleCoder, policy, EngineFunc(func(ctx context.Context, input StepInput) (StepOutput, error) {
+		return StepOutput{
+			Delta: "patched files",
+			Done:  true,
+			Output: Output{
+				Summary:     "done",
+				Findings:    []string{"root cause fixed"},
+				Patches:     []string{"a.go"},
+				Risks:       []string{"need integration verify"},
+				NextActions: []string{"run tests"},
+				Artifacts:   []string{"test report"},
+			},
+		}, nil
+	}))
+	if err != nil {
+		t.Fatalf("NewWorker() error = %v", err)
+	}
+
+	err = w.Start(Task{ID: "t1", Goal: "fix bug"}, Budget{MaxSteps: 3}, Capability{
+		AllowedTools: []string{"bash", "bash", " "},
+	})
+	if err != nil {
+		t.Fatalf("Start() error = %v", err)
+	}
+
+	step, err := w.Step(context.Background())
+	if err != nil {
+		t.Fatalf("Step() error = %v", err)
+	}
+	if !step.Done || step.State != StateSucceeded {
+		t.Fatalf("unexpected step result: %+v", step)
+	}
+
+	result, err := w.Result()
+	if err != nil {
+		t.Fatalf("Result() error = %v", err)
+	}
+	if result.StopReason != StopReasonCompleted {
+		t.Fatalf("stop reason = %q, want %q", result.StopReason, StopReasonCompleted)
+	}
+	if result.StepCount != 1 {
+		t.Fatalf("step count = %d, want 1", result.StepCount)
+	}
+	if len(result.Capability.AllowedTools) != 1 {
+		t.Fatalf("expected capability dedupe, got %+v", result.Capability)
+	}
+}
+
+func TestWorkerLifecycleFailures(t *testing.T) {
+	t.Parallel()
+
+	policy, err := DefaultRolePolicy(RoleResearcher)
+	if err != nil {
+		t.Fatalf("DefaultRolePolicy() error = %v", err)
+	}
+
+	t.Run("engine error", func(t *testing.T) {
+		t.Parallel()
+
+		w, err := NewWorker(RoleResearcher, policy, EngineFunc(func(ctx context.Context, input StepInput) (StepOutput, error) {
+			return StepOutput{}, errors.New("boom")
+		}))
+		if err != nil {
+			t.Fatalf("NewWorker() error = %v", err)
+		}
+		if err := w.Start(Task{ID: "t2", Goal: "research"}, Budget{MaxSteps: 2}, Capability{}); err != nil {
+			t.Fatalf("Start() error = %v", err)
+		}
+		if _, err := w.Step(context.Background()); err == nil {
+			t.Fatalf("expected step error")
+		}
+		result, err := w.Result()
+		if err != nil {
+			t.Fatalf("Result() error = %v", err)
+		}
+		if result.State != StateFailed || result.StopReason != StopReasonError {
+			t.Fatalf("unexpected result: %+v", result)
+		}
+	})
+
+	t.Run("max steps", func(t *testing.T) {
+		t.Parallel()
+
+		w, err := NewWorker(RoleResearcher, policy, EngineFunc(func(ctx context.Context, input StepInput) (StepOutput, error) {
+			return StepOutput{Delta: "not done", Done: false}, nil
+		}))
+		if err != nil {
+			t.Fatalf("NewWorker() error = %v", err)
+		}
+		if err := w.Start(Task{ID: "t3", Goal: "research"}, Budget{MaxSteps: 1}, Capability{}); err != nil {
+			t.Fatalf("Start() error = %v", err)
+		}
+		step, err := w.Step(context.Background())
+		if err != nil {
+			t.Fatalf("Step() error = %v", err)
+		}
+		if !step.Done || step.State != StateFailed {
+			t.Fatalf("expected first step to finish by max steps, got %+v", step)
+		}
+
+		result, err := w.Result()
+		if err != nil {
+			t.Fatalf("Result() error = %v", err)
+		}
+		if result.StopReason != StopReasonMaxSteps {
+			t.Fatalf("stop reason = %q, want %q", result.StopReason, StopReasonMaxSteps)
+		}
+	})
+
+	t.Run("timeout", func(t *testing.T) {
+		t.Parallel()
+
+		w, err := NewWorker(RoleResearcher, policy, EngineFunc(func(ctx context.Context, input StepInput) (StepOutput, error) {
+			return StepOutput{Done: false}, nil
+		}))
+		if err != nil {
+			t.Fatalf("NewWorker() error = %v", err)
+		}
+		if err := w.Start(Task{ID: "t4", Goal: "research"}, Budget{MaxSteps: 5, Timeout: time.Nanosecond}, Capability{}); err != nil {
+			t.Fatalf("Start() error = %v", err)
+		}
+		time.Sleep(2 * time.Millisecond)
+
+		step, err := w.Step(context.Background())
+		if err != nil {
+			t.Fatalf("Step() error = %v", err)
+		}
+		if !step.Done || step.State != StateFailed {
+			t.Fatalf("unexpected timeout step: %+v", step)
+		}
+		result, err := w.Result()
+		if err != nil {
+			t.Fatalf("Result() error = %v", err)
+		}
+		if result.StopReason != StopReasonTimeout {
+			t.Fatalf("stop reason = %q, want %q", result.StopReason, StopReasonTimeout)
+		}
+	})
+}
+
+func TestWorkerStopAndGuards(t *testing.T) {
+	t.Parallel()
+
+	policy, err := DefaultRolePolicy(RoleReviewer)
+	if err != nil {
+		t.Fatalf("DefaultRolePolicy() error = %v", err)
+	}
+
+	w, err := NewWorker(RoleReviewer, policy, nil)
+	if err != nil {
+		t.Fatalf("NewWorker() error = %v", err)
+	}
+
+	if _, err := w.Result(); err == nil {
+		t.Fatalf("expected result before finish to fail")
+	}
+	if _, err := w.Step(context.Background()); err == nil {
+		t.Fatalf("expected step before start to fail")
+	}
+	if err := w.Start(Task{ID: "review", Goal: "review"}, Budget{}, Capability{}); err != nil {
+		t.Fatalf("Start() error = %v", err)
+	}
+	if err := w.Start(Task{ID: "review2", Goal: "review2"}, Budget{}, Capability{}); err == nil {
+		t.Fatalf("expected double start to fail")
+	}
+	if err := w.Stop(StopReasonCanceled); err != nil {
+		t.Fatalf("Stop() error = %v", err)
+	}
+	if w.State() != StateCanceled {
+		t.Fatalf("state = %q, want %q", w.State(), StateCanceled)
+	}
+	if err := w.Stop(StopReasonCanceled); err != nil {
+		t.Fatalf("terminal stop should be idempotent, got %v", err)
+	}
+}
+
+func TestWorkerFactoryCreate(t *testing.T) {
+	t.Parallel()
+
+	factory := NewWorkerFactory(func(role Role, policy RolePolicy) Engine {
+		return EngineFunc(func(ctx context.Context, input StepInput) (StepOutput, error) {
+			return StepOutput{
+				Done: true,
+				Output: Output{
+					Summary:     "ok",
+					Findings:    []string{"f1"},
+					Patches:     []string{"p1"},
+					Risks:       []string{"r1"},
+					NextActions: []string{"n1"},
+					Artifacts:   []string{"a1"},
+				},
+			}, nil
+		})
+	})
+
+	w, err := factory.Create(RoleCoder)
+	if err != nil {
+		t.Fatalf("Create() error = %v", err)
+	}
+	if w.Policy().Role != RoleCoder {
+		t.Fatalf("policy role = %q, want %q", w.Policy().Role, RoleCoder)
+	}
+
+	if _, err := factory.Create(Role("invalid")); err == nil {
+		t.Fatalf("expected invalid role create to fail")
+	}
+}
+
+func TestWorkerRejectsInvalidOutputContract(t *testing.T) {
+	t.Parallel()
+
+	policy, err := DefaultRolePolicy(RoleCoder)
+	if err != nil {
+		t.Fatalf("DefaultRolePolicy() error = %v", err)
+	}
+	w, err := NewWorker(RoleCoder, policy, EngineFunc(func(ctx context.Context, input StepInput) (StepOutput, error) {
+		return StepOutput{
+			Done: true,
+			Output: Output{
+				Summary: "   ",
+			},
+		}, nil
+	}))
+	if err != nil {
+		t.Fatalf("NewWorker() error = %v", err)
+	}
+	if err := w.Start(Task{ID: "t-invalid-output", Goal: "goal"}, Budget{MaxSteps: 3}, Capability{}); err != nil {
+		t.Fatalf("Start() error = %v", err)
+	}
+
+	if _, err := w.Step(context.Background()); err == nil {
+		t.Fatalf("expected invalid output contract error")
+	}
+	result, err := w.Result()
+	if err != nil {
+		t.Fatalf("Result() error = %v", err)
+	}
+	if result.State != StateFailed || result.StopReason != StopReasonError {
+		t.Fatalf("unexpected result: %+v", result)
+	}
+}
+
+func TestWorkerStartCapabilityPolicyGuard(t *testing.T) {
+	t.Parallel()
+
+	policy, err := DefaultRolePolicy(RoleReviewer)
+	if err != nil {
+		t.Fatalf("DefaultRolePolicy() error = %v", err)
+	}
+
+	w, err := NewWorker(RoleReviewer, policy, nil)
+	if err != nil {
+		t.Fatalf("NewWorker() error = %v", err)
+	}
+
+	if err := w.Start(Task{ID: "t-cap", Goal: "goal"}, Budget{}, Capability{
+		AllowedTools: []string{"filesystem_read_file", "bash"},
+	}); err == nil {
+		t.Fatalf("expected disallowed capability tool to fail")
+	}
+
+	wPath, err := NewWorker(RoleReviewer, policy, nil)
+	if err != nil {
+		t.Fatalf("NewWorker() error = %v", err)
+	}
+	if err := wPath.Start(Task{ID: "t-cap-path", Goal: "goal"}, Budget{}, Capability{
+		AllowedPaths: []string{"/tmp/workspace"},
+	}); err == nil {
+		t.Fatalf("expected unsupported allowed paths to fail")
+	}
+
+	w2, err := NewWorker(RoleReviewer, policy, nil)
+	if err != nil {
+		t.Fatalf("NewWorker() error = %v", err)
+	}
+	if err := w2.Start(Task{ID: "t-cap-ok", Goal: "goal"}, Budget{}, Capability{}); err != nil {
+		t.Fatalf("Start() error = %v", err)
+	}
+	if err := w2.Stop(StopReasonCanceled); err != nil {
+		t.Fatalf("Stop() error = %v", err)
+	}
+	result, err := w2.Result()
+	if err != nil {
+		t.Fatalf("Result() error = %v", err)
+	}
+	if len(result.Capability.AllowedTools) != len(policy.AllowedTools) {
+		t.Fatalf("capability tools = %v, want policy tools %v", result.Capability.AllowedTools, policy.AllowedTools)
+	}
+}
+
+func TestWorkerTraceWindow(t *testing.T) {
+	t.Parallel()
+
+	policy, err := DefaultRolePolicy(RoleResearcher)
+	if err != nil {
+		t.Fatalf("DefaultRolePolicy() error = %v", err)
+	}
+
+	var observedTraceLen int
+	w, err := NewWorker(RoleResearcher, policy, EngineFunc(func(ctx context.Context, input StepInput) (StepOutput, error) {
+		observedTraceLen = len(input.Trace)
+		return StepOutput{
+			Done: true,
+			Output: Output{
+				Summary:     "done",
+				Findings:    []string{"f1"},
+				Patches:     []string{"p1"},
+				Risks:       []string{"r1"},
+				NextActions: []string{"n1"},
+				Artifacts:   []string{"a1"},
+			},
+		}, nil
+	}))
+	if err != nil {
+		t.Fatalf("NewWorker() error = %v", err)
+	}
+	impl, ok := w.(*worker)
+	if !ok {
+		t.Fatalf("expected *worker implementation")
+	}
+	impl.trace = make([]string, traceWindowSize+4)
+	for i := range impl.trace {
+		impl.trace[i] = "trace"
+	}
+	impl.state = StateRunning
+	impl.task = Task{ID: "trace", Goal: "goal"}
+	impl.budget = Budget{MaxSteps: 5, Timeout: time.Second}
+	impl.capability = Capability{}
+	impl.startedAt = time.Now()
+
+	if _, err := w.Step(context.Background()); err != nil {
+		t.Fatalf("Step() error = %v", err)
+	}
+	if observedTraceLen != traceWindowSize {
+		t.Fatalf("trace len = %d, want %d", observedTraceLen, traceWindowSize)
+	}
+}
+
+func TestWorkerTraceStorageBounded(t *testing.T) {
+	t.Parallel()
+
+	policy, err := DefaultRolePolicy(RoleResearcher)
+	if err != nil {
+		t.Fatalf("DefaultRolePolicy() error = %v", err)
+	}
+
+	w, err := NewWorker(RoleResearcher, policy, EngineFunc(func(ctx context.Context, input StepInput) (StepOutput, error) {
+		if input.StepIndex < traceWindowSize+8 {
+			return StepOutput{Delta: "delta", Done: false}, nil
+		}
+		return StepOutput{
+			Delta: "delta",
+			Done:  true,
+			Output: Output{
+				Summary:     "done",
+				Findings:    []string{"f1"},
+				Patches:     []string{"p1"},
+				Risks:       []string{"r1"},
+				NextActions: []string{"n1"},
+				Artifacts:   []string{"a1"},
+			},
+		}, nil
+	}))
+	if err != nil {
+		t.Fatalf("NewWorker() error = %v", err)
+	}
+	if err := w.Start(Task{ID: "t-trace-bounded", Goal: "goal"}, Budget{MaxSteps: traceWindowSize + 16}, Capability{}); err != nil {
+		t.Fatalf("Start() error = %v", err)
+	}
+
+	for {
+		step, stepErr := w.Step(context.Background())
+		if stepErr != nil {
+			t.Fatalf("Step() error = %v", stepErr)
+		}
+		if step.Done {
+			break
+		}
+	}
+
+	impl, ok := w.(*worker)
+	if !ok {
+		t.Fatalf("expected *worker implementation")
+	}
+	if len(impl.trace) != traceWindowSize {
+		t.Fatalf("trace storage len = %d, want %d", len(impl.trace), traceWindowSize)
+	}
+}
+
+func TestWorkerNilAndValidationBranches(t *testing.T) {
+	t.Parallel()
+
+	if _, err := NewWorker(Role("bad"), RolePolicy{}, nil); err == nil {
+		t.Fatalf("expected invalid role error")
+	}
+	if _, err := NewWorker(RoleCoder, RolePolicy{Role: RoleReviewer, SystemPrompt: "p", AllowedTools: []string{"bash"}, RequiredSections: []string{"summary"}}, nil); err == nil {
+		t.Fatalf("expected role mismatch error")
+	}
+
+	var nilWorker *worker
+	if err := nilWorker.Start(Task{}, Budget{}, Capability{}); err == nil {
+		t.Fatalf("expected nil worker start error")
+	}
+	if _, err := nilWorker.Step(context.Background()); err == nil {
+		t.Fatalf("expected nil worker step error")
+	}
+	if err := nilWorker.Stop(StopReasonCanceled); err == nil {
+		t.Fatalf("expected nil worker stop error")
+	}
+	if _, err := nilWorker.Result(); err == nil {
+		t.Fatalf("expected nil worker result error")
+	}
+	if nilWorker.State() != StateIdle {
+		t.Fatalf("nil worker state = %q, want %q", nilWorker.State(), StateIdle)
+	}
+	nilPolicy := nilWorker.Policy()
+	if nilPolicy.Role != "" || nilPolicy.SystemPrompt != "" || len(nilPolicy.AllowedTools) != 0 || len(nilPolicy.RequiredSections) != 0 {
+		t.Fatalf("nil worker policy should be empty, got %+v", nilPolicy)
+	}
+}