DeepSeek-Reasonix/internal/agent/coordinator.go

package agent

import (
	"context"
	"errors"
	"fmt"
	"strings"
	"time"

	"reasonix/internal/event"
	"reasonix/internal/nilutil"
	"reasonix/internal/plancontract"
	"reasonix/internal/planmode"
	"reasonix/internal/provider"
	"reasonix/internal/sandbox"
	"reasonix/internal/tool"
)

// Runner carries out one task turn. Both Agent (single model) and Coordinator
// (two-model) satisfy it, so the CLI stays agnostic to which is in use.
type Runner interface {
	Run(ctx context.Context, input string) error
}

// PlannerPlanApprover lets hosts bind a planner-authored approval request to
// their native approval UI without making the agent package depend on control.
type PlannerPlanApprover interface {
	RunWithPlannerApproval(ctx context.Context, plan string, run func(context.Context) error) error
}

// DefaultPlannerPrompt steers the planner toward concise plans, not execution.
const DefaultPlannerPrompt = `You are the planner in a two-model coding agent.
Given a task, produce a concise, ordered plan for the executor model to carry out.
Use the read-only tools available to you when the task needs context from the
workspace, user rules, or docs; keep that research targeted and stop once you
have enough evidence. Do not write full implementations or attempt side effects.
Do not ask the user how to trigger the executor and do not say you are waiting
for the executor. Output executor-ready instructions: what to do, which files or
commands are relevant, expected blockers, and key decisions. Keep it short and
actionable.

Deliver the plan by calling submit_plan. The plan is data, not prose: the host
renders it for the user and hands it to the executor, so do not also write the
plan out in your reply. Fill the fields you actually have — a step's title is
required, everything else is there so the plan can say what free text only
implies. Record read paths as verified_files and inferred ones as
candidate_files; never present an unread path as verified. Set requires_approval
when execution should stop for the user; the host owns the final decision.

A host-authored <planner-turn> block at the end of the user turn selects the
planning depth. For depth=light, submit a compact objective with 1-4 steps,
likely touchpoints, and the main verification. For depth=full, inspect enough
evidence to separate verified touchpoints from candidates, then also fill
non-goals, per-step risks, acceptance criteria, and command-level verification.
Label anything unproven in assumptions rather than stating it as fact.

If execution needs a user-owned decision or a missing user-provided value
before it can be safe, call ask and let the answer shape the plan; never ask in
prose and never plan around a guess you could have settled.

Crucial: You only have research tools plus the stable use_capability proxy for
authorized MCP. You do NOT have bash, execute, file writers, or other
side-effect tools — those belong to the executor. Never question or dwell on
the lack of execution tools; it is by design. Just plan what the executor
should do with its tools.

When you need external real data and the capability route does not name a
specific tool, call use_capability(action="search") with the goal before saying
the capability is unavailable, then inspect or call a non-destructive result. If a capability is
destructive, do not treat that as missing configuration or an unavailable MCP:
write the operation into the plan for the executor instead.

If the task needs no executor actions at all, call conclude_no_changes instead
of submit_plan. That covers two cases: your research shows the work is already
done (already implemented, already resolved), and the task is a question,
comparison, analysis, or explanation that an answer fully settles — put the
complete answer in its reason field, which the host delivers directly instead of
starting the executor. Never conclude that way when any workspace change,
command, verification, or follow-up action remains.`

const executorHandoffMarker = "Reasonix executor handoff"

// plannerFallbackNotice is shown when the planner fails and the turn degrades
// to executor-only instead of failing outright.
const plannerFallbackNotice = "Planner failed; continuing this turn with the executor only."

// A host-owned research budget must cap planner cost without stranding an
// ordinary task. If the planner ignores its finalization nudge, the executor
// still owns the task and can inspect the workspace directly. Explicit
// no-execution and approval boundaries remain fail-closed.
const (
	plannerResearchFallbackNotice = "Planner reached its research limit without a final plan; continuing this turn with the executor."
	plannerResearchBoundaryError  = "planner could not finalize within its research budget; no execution was started"
)

// PlannerPromptWithContext appends cache-stable standing context, such as loaded
// REASONIX.md / AGENTS.md memory, to the planner's smaller system prompt.
func PlannerPromptWithContext(context string) string {
	context = strings.TrimSpace(context)
	if context == "" {
		return DefaultPlannerPrompt
	}
	return DefaultPlannerPrompt + "\n\n# Planning context\n\n" + context
}

// Coordinator runs two models in separate sessions to keep each one's prompt
// prefix cache-stable: a low-frequency planner proposes an approach, then the
// executor (a full tool-using Agent) carries it out. The sessions never mix, so
// neither model's prefix is disturbed by the other's turns.
type Coordinator struct {
	planner         provider.Provider
	plannerSess     *Session
	plannerSystem   string
	plannerPricing  *provider.Pricing
	plannerModelRef string
	plannerAgent    *Agent
	executor        *Agent
	temperature     float64
	sink            event.Sink
	// plannerPolicy chooses executor-only, plan-and-execute, or plan-for-approval
	// per turn. nil preserves the historical "plan every turn" constructor
	// behavior used by direct Coordinator callers.
	plannerPolicy       PlannerPolicy
	plannerPlanApprover PlannerPlanApprover
}

// NewCoordinator wires a planner provider (with its own session) to an executor.
// sink receives the planner's phase/text/usage events; the executor emits its
// own events to its own sink (the CLI wires the same sink into both). A nil
// sink is replaced with event.Discard.
func NewCoordinator(planner provider.Provider, plannerSession *Session, plannerPricing *provider.Pricing, plannerTools *tool.Registry, plannerOptions Options, executor *Agent, temperature float64, sink event.Sink, shouldPlan func(context.Context, string) bool) *Coordinator {
	var policy PlannerPolicy
	if shouldPlan != nil {
		policy = func(ctx context.Context, input string) PlannerDecision {
			if !shouldPlan(ctx, input) {
				return PlannerDecision{Route: PlannerRouteExecutorOnly, Reason: "legacy_skip"}
			}
			return PlannerDecision{Route: PlannerRoutePlanAndExecute, Depth: PlannerDepthFull, Reason: "legacy_plan"}
		}
	}
	return newCoordinator(planner, plannerSession, plannerPricing, plannerTools, plannerOptions, executor, temperature, sink, policy)
}

// NewCoordinatorWithPlannerPolicy wires the structured deterministic planner
// router used by the product boot path. NewCoordinator remains as a compatibility
// adapter for direct callers and older tests that still provide a bool gate.
func NewCoordinatorWithPlannerPolicy(planner provider.Provider, plannerSession *Session, plannerPricing *provider.Pricing, plannerTools *tool.Registry, plannerOptions Options, executor *Agent, temperature float64, sink event.Sink, policy PlannerPolicy) *Coordinator {
	return newCoordinator(planner, plannerSession, plannerPricing, plannerTools, plannerOptions, executor, temperature, sink, policy)
}

func newCoordinator(planner provider.Provider, plannerSession *Session, plannerPricing *provider.Pricing, plannerTools *tool.Registry, plannerOptions Options, executor *Agent, temperature float64, sink event.Sink, policy PlannerPolicy) *Coordinator {
	if nilutil.IsNil(sink) {
		sink = event.Discard
	}
	if plannerSession == nil {
		plannerSession = NewSession("")
	}
	plannerSystem := sessionSystemPrompt(plannerSession)
	var plannerAgent *Agent
	if plannerTools != nil {
		plannerOptions.Temperature = temperature
		plannerOptions.Pricing = plannerPricing
		plannerOptions.UsageSource = event.UsageSourcePlanner
		plannerAgent = NewPlannerAgent(planner, plannerTools, plannerSession, plannerOptions, plannerSink(sink))
	}
	if executor != nil {
		executor.role.executorHandoff = true
	}
	return &Coordinator{
		planner:         planner,
		plannerSess:     plannerSession,
		plannerSystem:   plannerSystem,
		plannerPricing:  plannerPricing,
		plannerModelRef: strings.TrimSpace(plannerOptions.ModelRef),
		plannerAgent:    plannerAgent,
		executor:        executor,
		temperature:     temperature,
		sink:            sink,
		plannerPolicy:   policy,
	}
}

func sessionSystemPrompt(s *Session) string {
	if s == nil {
		return ""
	}
	for _, m := range s.Snapshot() {
		if m.Role == provider.RoleSystem {
			return m.Content
		}
	}
	return ""
}

// ResetPlannerSession discards turn-local planner history when the owning
// controller moves to a different executor session. Saved transcripts only
// persist executor-visible conversation; carrying the old planner transcript
// into a new/resumed session can make the next plan reuse unrelated tasks.
func (c *Coordinator) ResetPlannerSession() {
	if c == nil {
		return
	}
	system := c.plannerSystem
	if system == "" {
		system = sessionSystemPrompt(c.plannerSess)
	}
	next := NewSession(system)
	c.plannerSess = next
	if c.plannerAgent != nil {
		c.plannerAgent.SetSession(next)
	}
}

// PlannerAgent returns the tool-enabled planner agent, if any. Controllers use
// it to seed turn-scoped capability routes without coupling to Coordinator
// internals beyond this accessor.
func (c *Coordinator) PlannerAgent() *Agent {
	if c == nil {
		return nil
	}
	return c.plannerAgent
}

// SetReasoningLanguage updates both agents in two-model mode. The raw planner
// path receives controller-composed input directly, but a tool-enabled planner
// owns its own Agent and must clear stale zh/en preferences on live changes.
func (c *Coordinator) SetReasoningLanguage(lang string) {
	if c == nil {
		return
	}
	if c.plannerAgent != nil {
		c.plannerAgent.SetReasoningLanguage(lang)
	}
	if c.executor != nil {
		c.executor.SetReasoningLanguage(lang)
	}
}

// SetResponseLanguage updates both agents in two-model mode.
func (c *Coordinator) SetResponseLanguage(lang string) {
	if c == nil {
		return
	}
	if c.plannerAgent != nil {
		c.plannerAgent.SetResponseLanguage(lang)
	}
	if c.executor != nil {
		c.executor.SetResponseLanguage(lang)
	}
}

// SetPlanMode propagates the plan-first workflow flag to both planner and executor agents
// in two-model mode. Callers that only set the controller's executor would miss
// the planner agent inside the Coordinator, causing stale plan-mode state after
// approvals or manual mode switches.
// AdoptPlanRuntime gives both agents the one lifecycle the controller drives.
func (c *Coordinator) AdoptPlanRuntime(r *planmode.Runtime) {
	if c == nil {
		return
	}
	if c.plannerAgent != nil {
		c.plannerAgent.AdoptPlanRuntime(r)
	}
	if c.executor != nil {
		c.executor.AdoptPlanRuntime(r)
	}
}

func (c *Coordinator) SetPlanMode(v bool) {
	if c == nil {
		return
	}
	if c.plannerAgent != nil {
		c.plannerAgent.SetPlanMode(v)
	}
	if c.executor != nil {
		c.executor.SetPlanMode(v)
	}
}

// SetSandboxEscapeApprover propagates one-shot shell sandbox escape approvals to
// both tool-using agents in two-model mode.
func (c *Coordinator) SetSandboxEscapeApprover(g sandbox.EscapeApprover) {
	if c == nil {
		return
	}
	if c.plannerAgent != nil {
		c.plannerAgent.SetSandboxEscapeApprover(g)
	}
	if c.executor != nil {
		c.executor.SetSandboxEscapeApprover(g)
	}
}

// SetConfigWriteApprover propagates Reasonix-managed config write approvals to
// both tool-using agents in two-model mode.
func (c *Coordinator) SetConfigWriteApprover(g tool.ConfigWriteApprover) {
	if c == nil {
		return
	}
	if c.plannerAgent != nil {
		c.plannerAgent.SetConfigWriteApprover(g)
	}
	if c.executor != nil {
		c.executor.SetConfigWriteApprover(g)
	}
}

// SetPlannerPlanApprover connects planner-authored "wait for approval" outputs
// to the host's approval surface. Without one, Coordinator keeps the legacy
// direct handoff behavior so non-interactive runs cannot block forever.
func (c *Coordinator) SetPlannerPlanApprover(g PlannerPlanApprover) {
	if c == nil {
		return
	}
	c.plannerPlanApprover = g
}

// Run plans with the planner model, then hands the plan to the executor.
func (c *Coordinator) Run(ctx context.Context, input string) error {
	// A host that announced this turn owns its boundary; opening a second one
	// here would make planner work and executor work two turns to every sink
	// that resets on a start.
	if _, hosted := HostTurnBoundaryFrom(ctx); !hosted {
		c.sink.Emit(event.Event{Kind: event.TurnStarted})
	}
	// A turn starts owing nothing to the last one's plan; deliverPlan installs
	// this turn's plan only once the executor is actually about to run it.
	c.executor.SetPlanContract(nil)
	decision := PlannerDecision{
		Route:  PlannerRoutePlanAndExecute,
		Depth:  PlannerDepthFull,
		Reason: "always_plan",
	}
	if c.plannerPolicy != nil {
		decision = normalizePlannerDecision(c.plannerPolicy(ctx, input))
	}
	routeDetail := fmt.Sprintf("planner route=%s depth=%s reason=%s", decision.Route, decision.Depth, decision.Reason)
	if decision.Route == PlannerRouteExecutorOnly {
		c.sink.Emit(event.Event{Kind: event.Phase, Text: c.executor.svc.prov.Name() + " · executing", Detail: routeDetail, Source: event.UsageSourceExecutor})
		return c.executor.Run(ctx, input)
	}
	c.sink.Emit(event.Event{Kind: event.Phase, Text: c.planner.Name() + " · planning", Detail: routeDetail, Source: event.UsageSourcePlanner})
	plannerCtx := tool.WithoutGoalTurnRecorder(ctx)
	if decision.MaxResearchRounds > 0 {
		plannerCtx = withRunStepLimit(plannerCtx, decision.MaxResearchRounds, "planner research rounds")
	}
	plannerInput := plannerTurnInput(input, decision)
	outcome, err := c.plan(plannerCtx, plannerInput)
	if err != nil {
		if ctx.Err() != nil {
			return fmt.Errorf("planner: %w", err)
		}
		if isToolLoopPause(err) {
			// Per-turn research depth is host policy, not a user-facing
			// configuration or a reason to strand the conversation. Ordinary
			// plan-and-execute work degrades to the executor with the pristine
			// task. Explicit execution boundaries fail closed because no
			// complete plan exists to approve or return.
			if decision.Route != PlannerRoutePlanAndExecute {
				return fmt.Errorf("%s", plannerResearchBoundaryError)
			}
			c.sink.Emit(event.Event{
				Kind:   event.Notice,
				Level:  event.LevelWarn,
				Text:   plannerResearchFallbackNotice,
				Detail: plannerResearchPauseDetail(err),
				Source: event.UsageSourcePlanner,
			})
			c.sink.Emit(event.Event{Kind: event.Phase, Text: c.executor.svc.prov.Name() + " · executing", Source: event.UsageSourceExecutor})
			return c.executor.Run(ctx, input)
		}
		// Plan-only explicitly excludes execution, while plan-for-approval
		// excludes it until the host records approval. Falling back directly
		// to the executor would turn a planner outage into an unauthorized
		// state change, so preserve either boundary and surface the failure.
		if decision.Route == PlannerRoutePlanOnly || decision.Route == PlannerRoutePlanForApproval {
			return fmt.Errorf("planner: %w", err)
		}
		// A planner failure must not take down the turn: the executor is
		// healthy and owns the full tool set, so degrade to single-model for
		// this turn.
		c.sink.Emit(event.Event{Kind: event.Notice, Level: event.LevelWarn, Text: plannerFallbackNotice, Detail: "planner failed; running the executor without a plan: " + err.Error(), Source: event.UsageSourcePlanner})
		c.sink.Emit(event.Event{Kind: event.Phase, Text: c.executor.svc.prov.Name() + " · executing", Source: event.UsageSourceExecutor})
		return c.executor.Run(ctx, input)
	}
	return c.deliverPlan(ctx, input, outcome, decision)
}

// deliverPlan routes a finished plan to its ending: relayed conclusion, plan
// only, approval gate, user decision, or straight to the executor. Split out of
// Run so the routing reads as one decision table.
func (c *Coordinator) deliverPlan(ctx context.Context, input string, outcome plannerOutcome, decision PlannerDecision) error {
	plan := outcome.text
	if outcome.exit == plannerExitNoChanges {
		c.persistExecutorNoOp(ctx, input, plan)
		// The relayed conclusion is planner text; keep its source so sinks
		// attribute it like every other planner emission.
		c.sink.Emit(event.Event{Kind: event.Text, Text: DisplayAssistantText(plan), Source: event.UsageSourcePlanner})
		return nil
	}
	runExecutorWithPlan := func(ctx context.Context, planText string) error {
		if outcome.exit == plannerExitPlan {
			c.executor.SetPlanContract(&outcome.plan)
		}
		c.sink.Emit(event.Event{Kind: event.Phase, Text: c.executor.svc.prov.Name() + " · executing", Source: event.UsageSourceExecutor})
		return c.executor.Run(ctx, formatHandoffWithDecision(input, planText, decision, executorToolHandoffContext(c.executor)))
	}
	runWithPlanApproval := func() error {
		if c.plannerPlanApprover == nil {
			c.persistExecutorNoOp(ctx, input, plan+"\n\n"+plannerPlanAwaitingApprovalNote)
			c.sink.Emit(event.Event{Kind: event.Notice, Level: event.LevelInfo, Text: plannerPlanAwaitingApprovalNotice, Source: event.UsageSourcePlanner})
			return nil
		}
		executed := false
		err := c.plannerPlanApprover.RunWithPlannerApproval(ctx, plan, func(ctx context.Context) error {
			executed = true
			return runExecutorWithPlan(ctx, plan)
		})
		if err == nil && !executed && ctx.Err() == nil {
			// The user declined the plan. Persist the exchange like the no-op
			// path does — a denied turn must survive session save/reload, and
			// the note tells the next executor turn that nothing ran.
			c.persistExecutorNoOp(ctx, input, plan+"\n\n"+plannerPlanNotApprovedNote)
			c.sink.Emit(event.Event{Kind: event.Notice, Level: event.LevelInfo, Text: plannerPlanNotApprovedNotice, Source: event.UsageSourcePlanner})
		}
		return err
	}
	if decision.Route == PlannerRoutePlanOnly {
		c.persistExecutorNoOp(ctx, input, plan+"\n\n"+plannerPlanOnlyNote)
		c.sink.Emit(event.Event{Kind: event.Notice, Level: event.LevelInfo, Text: plannerPlanOnlyNotice, Source: event.UsageSourcePlanner})
		return nil
	}
	if decision.Route == PlannerRoutePlanForApproval {
		return runWithPlanApproval()
	}
	if outcome.requestsApproval() {
		return runWithPlanApproval()
	}
	return runExecutorWithPlan(ctx, plan)
}

// Persisted-session notes and user-facing notices for planner turns that ended
// without an executor run. The notes become the turn's assistant message in the
// executor session, so the next turn's executor knows nothing was executed.
const (
	plannerPlanNotApprovedNote        = "(The user did not approve this plan; execution was not started.)"
	plannerPlanNotApprovedNotice      = "Plan not approved; nothing was executed. Reply to continue."
	plannerPlanAwaitingApprovalNote   = "(The user requested planning before execution; no action was started without host approval.)"
	plannerPlanAwaitingApprovalNotice = "Plan ready; execution was not started without approval."
	plannerPlanOnlyNote               = "(The user explicitly requested a plan without execution; no action was started.)"
	plannerPlanOnlyNotice             = "Plan ready; the request explicitly excluded execution."
	plannerDecisionUnansweredNote     = "(The user did not provide the requested decision; execution was not started.)"
	plannerDecisionUnansweredNotice   = "Waiting for your decision; nothing was executed. Reply to continue."
)

func (c *Coordinator) persistExecutorNoOp(ctx context.Context, input, plan string) {
	if c == nil || c.executor == nil || c.executor.sess.conversation == nil {
		return
	}
	// A turn nobody executed is still the turn the host named. It lands through
	// the same seam an executed one does, so the identity published for it holds
	// whichever way the turn ended.
	c.executor.LandAuthoredUserMessage(ctx, provider.Message{
		Role: provider.RoleUser, Content: c.executor.withTurnPreferences(input),
		RawContent: RawUserInput(ctx, input),
		Images:     userImages(ctx), CreatedAt: time.Now().UnixMilli(),
	})
	c.executor.sess.conversation.Add(provider.Message{Role: provider.RoleAssistant, Content: plan})
}

// plannerOutcome is one planning turn's result. A submitted plan is the
// contract; text is what the user and the executor read — rendered from the plan
// when there is one, the planner's prose when there is not.
// plannerExit is how the planning turn ended. The three are mutually exclusive
// by construction, so no combination of flags can claim a plan and a no-op at
// once.
type plannerExit uint8

const (
	// plannerExitProse is a planner that called neither structured exit. Its
	// text is handed to the executor as-is; the host reads no decision out of
	// it, because prose has no field to read.
	plannerExitProse plannerExit = iota
	plannerExitPlan
	plannerExitNoChanges
)

type plannerOutcome struct {
	text string
	plan plancontract.Plan
	exit plannerExit
}

// requestsApproval reports whether execution should stop for the user. Only a
// submitted plan can say so; the host's own routes (plan mode, an explicit
// request for a plan) decide it in every other case.
func (o plannerOutcome) requestsApproval() bool {
	return o.exit == plannerExitPlan && o.plan.RequiresApproval
}

// plan produces this turn's plan, carrying which structured exit the planner
// took. The product path always has the exits available; a tool-less planner
// can only return prose, which the executor receives as plain instructions.
func (c *Coordinator) plan(ctx context.Context, input string) (plannerOutcome, error) {
	if c.plannerAgent != nil {
		return c.planWithTools(ctx, input)
	}
	text, err := c.planFromStream(ctx, input)
	return plannerOutcome{text: text}, err
}

// planFromStream is the tool-less planner path: with no structured exit
// available its result is always prose, handed to the executor as-is.
func (c *Coordinator) planFromStream(ctx context.Context, input string) (string, error) {
	// On failure, roll the just-added user message back: a dangling user turn
	// would produce consecutive user roles on the next plan (which some
	// providers reject), and Run's executor fallback keeps the turn alive
	// after this error, so the planner session must stay coherent.
	before := c.plannerSess.Snapshot()
	rawInput := RawUserInput(ctx, input)
	rawContent := ""
	if input != rawInput {
		rawContent = rawInput
	}
	c.plannerSess.Add(provider.Message{Role: provider.RoleUser, Content: input, RawContent: rawContent})
	ctx = provider.WithRequestAttemptCounter(ctx)
	var usage *provider.Usage
	streamCompleted := false
	defer func() {
		accounted := provider.UsageWithRequestAttemptCount(ctx, usage)
		if accounted != nil || streamCompleted {
			c.sink.Emit(event.Event{Kind: event.Usage, ModelRef: c.plannerModelRef, Usage: accounted, Pricing: c.plannerPricing, Source: event.UsageSourcePlanner, UsageSource: event.UsageSourcePlanner})
		}
	}()

	planCtx, planCancel := context.WithCancel(ctx)
	defer planCancel()
	defer trackPublishedHostStream(planCtx, planCancel)()
	ch, err := c.planner.Stream(planCtx, provider.Request{
		Messages:    provider.ModelMessages(c.plannerSess.Messages),
		Temperature: provider.OptionalTemperature(c.temperature),
	})
	if err != nil {
		c.plannerSess.Replace(before)
		return "", err
	}

	var text strings.Builder
	for chunk := range ch {
		switch chunk.Type {
		case provider.ChunkText:
			text.WriteString(chunk.Text)
			c.sink.Emit(event.Event{Kind: event.Text, Text: chunk.Text, Source: event.UsageSourcePlanner})
		case provider.ChunkUsage:
			usage = chunk.Usage
		case provider.ChunkError:
			c.plannerSess.Replace(before)
			return "", chunk.Err
		}
	}
	streamCompleted = true
	plan := text.String()
	c.plannerSess.Add(provider.Message{Role: provider.RoleAssistant, Content: plan})
	return plan, nil
}

// planWithTools runs the planner through the normal Agent loop over a filtered
// read-only registry. That gives the planner the same tool-call contract as the
// executor while preserving its separate session and cache prefix.
func (c *Coordinator) planWithTools(ctx context.Context, input string) (plannerOutcome, error) {
	before := c.plannerSess.Snapshot()
	rewriteBefore := c.plannerSess.RewriteVersion()
	ctx, submission := WithPlanSubmission(ctx)
	if err := c.plannerAgent.Run(ctx, input); err != nil {
		// Mirror plan()'s rollback: Run already appended the user message
		// (and possibly partial assistant/tool rounds) to the planner
		// session, and Coordinator.Run degrades to the executor on planner
		// failure. Research-budget pauses are also rolled back: ordinary work
		// falls back to the executor immediately, while explicit execution
		// boundaries surface a safe error. Retaining an unfinished planner
		// turn would leave a tool-call tail that the next provider request
		// cannot safely resume.
		c.rollbackPlannerTurn(before, rewriteBefore)
		return plannerOutcome{}, err
	}
	// A submitted plan is the contract, whatever the planner said afterwards.
	// The host renders it so the user sees the plan itself rather than the
	// planner's acknowledgement of having submitted it.
	if reason, ok := submission.NoChanges(); ok {
		return plannerOutcome{text: reason, exit: plannerExitNoChanges}, nil
	}
	if plan, ok := submission.Plan(); ok {
		text := plancontract.Render(plan)
		c.sink.Emit(event.Event{Kind: event.Text, Text: text, Source: event.UsageSourcePlanner})
		return plannerOutcome{text: text, plan: plan, exit: plannerExitPlan}, nil
	}
	// The plan is this turn's final answer: the last non-empty assistant
	// message appended after the pre-turn boundary. When a session rewrite
	// landed during the turn (auto-compaction fires right after the final
	// answer), the pre-turn length no longer maps to a boundary in the
	// rewritten log — it can even exceed it, hiding a successfully produced
	// plan. Rewrites keep the recent tail verbatim, so scanning the whole
	// rewritten session from the end still finds the final answer first.
	floor := len(before)
	if c.plannerSess.RewriteVersion() != rewriteBefore {
		floor = 0
	}
	for i := len(c.plannerSess.Messages) - 1; i >= floor; i-- {
		m := c.plannerSess.Messages[i]
		if m.Role == provider.RoleAssistant && strings.TrimSpace(m.Content) != "" {
			return plannerOutcome{text: m.Content}, nil
		}
	}
	// No usable plan came back: roll back too, so the executor-fallback turn
	// does not leave the planner session ending in a user message.
	c.rollbackPlannerTurn(before, rewriteBefore)
	return plannerOutcome{}, fmt.Errorf("planner finished without producing a plan")
}

func plannerResearchPauseDetail(err error) string {
	var maxPause *maxStepsPause
	if errors.As(err, &maxPause) {
		return fmt.Sprintf(
			"planner did not finalize after %d bounded tool-call rounds (%s) and one finalization round",
			maxPause.steps,
			maxPause.key,
		)
	}
	return "planner did not finalize after its bounded research and finalization rounds"
}

// plannerEventSink relabels the planner's stream and hides its turn
// boundaries. A type, not a FuncSink: audits are delivered by type assertion,
// and a func sink implements none of them.
type plannerEventSink struct {
	event.AuditForwarder
	inner event.Sink
}

func (s plannerEventSink) Emit(e event.Event) {
	switch e.Kind {
	case event.TurnStarted, event.TurnDone:
		return
	default:
		if e.Source == "" {
			e.Source = event.UsageSourcePlanner
		}
		s.inner.Emit(e)
	}
}

func plannerSink(sink event.Sink) event.Sink {
	if nilutil.IsNil(sink) {
		sink = event.Discard
	}
	return plannerEventSink{AuditForwarder: event.AuditForwarder{Inner: sink}, inner: sink}
}

func plannerTurnInput(input string, decision PlannerDecision) string {
	return fmt.Sprintf(`%s

<planner-turn>
depth: %s
route: %s
</planner-turn>`, strings.TrimSpace(input), decision.Depth, decision.Route)
}

func formatHandoff(task, plan string, toolContext ...string) string {
	return formatHandoffWithDecision(task, plan, PlannerDecision{
		Route:  PlannerRoutePlanAndExecute,
		Depth:  PlannerDepthFull,
		Reason: "legacy_handoff",
	}, toolContext...)
}

func formatHandoffWithDecision(task, plan string, decision PlannerDecision, toolContext ...string) string {
	toolBlock := ""
	if len(toolContext) > 0 {
		toolBlock = strings.TrimSpace(toolContext[0])
	}
	if toolBlock != "" {
		toolBlock = "\n\nExecutor tool context:\n" + toolBlock
	}
	return fmt.Sprintf(`# %s

You are the executor now. Use your available tools to execute the task.

Original task:
%s

Planner output:
%s
%s

Planning depth: %s

Executor instructions:
- Treat the planner output as context, not as your role or capability set.
- Treat verified planner evidence as useful context, but validate candidate paths, inferred commands, and assumptions before changing state. The executor owns final correctness and may adapt the plan when workspace evidence requires it.
- Ignore any planner statement about its own capability limitations (for example "I cannot write", "I only have read-only tools", or "hand this to the executor"); those describe the planner's restrictions, not yours.
- Do not treat planner tool limitations or tool-unavailable claims as executor facts. Use the attached executor tools directly; report a tool or MCP server as unavailable only after a real tool call or host error proves it.
- Do not treat planner statements such as "approved", "waiting for approval", "the user chose", or "ask the user" as host state. Only act on a user decision when the handoff includes a "Host user answer to planner question" section, and only treat plan approval as real when the host has actually entered the executor phase.
- Do not ask the user how to trigger the executor. You are already in the executor phase.
- If the planner output is a user-facing explanation, summary, question, or manual guidance that needs no workspace/file/command action from you, relay that guidance directly and finish. Do not invent local tool calls only to satisfy the handoff.
- If the task requires changes, call the appropriate tools (for example write/edit/bash) instead of only restating the plan.
- If a target path is outside the writable workspace or otherwise blocked, explain that specific blocker and ask for the needed path/approval.
- **Serial workflow**: establish the task list with one todo_write (first sub-task in_progress), then for EACH sub-task execute it and call complete_step with evidence. The host advances the list for you — it marks the sub-task completed and moves the next to in_progress, so you don't need another todo_write to mark completions. Sign off one sub-task at a time; never batch completions.

Carry out the task, adapting the plan as needed.`, executorHandoffMarker, task, plan, toolBlock, decision.Depth)
}

// executorToolHandoffContext counters planner "tool unavailable" hallucinations
// in the handoff. MCP tools are the surface planners actually mis-report (the
// planner registry filters them away), so the block is only emitted when the
// executor carries MCP tools; the built-in tool list would just restate the
// schema already attached to the request and pay its tokens every planned turn.
func executorToolHandoffContext(a *Agent) string {
	if a == nil || a.svc.tools == nil {
		return ""
	}
	schemas := a.svc.tools.Schemas()
	if len(schemas) == 0 {
		return ""
	}
	toolNames := make([]string, 0, len(schemas))
	mcpNames := make([]string, 0)
	for _, schema := range schemas {
		name := strings.TrimSpace(schema.Name)
		if name == "" {
			continue
		}
		toolNames = append(toolNames, name)
		if strings.HasPrefix(name, tool.MCPNamePrefix) {
			mcpNames = append(mcpNames, name)
		}
	}
	if len(mcpNames) == 0 {
		return ""
	}

	var b strings.Builder
	fmt.Fprintf(&b, "- The executor request includes the full tool schema (%d tools).", len(toolNames))
	fmt.Fprintf(&b, "\n- MCP tools are already registered for the executor in this request (%d MCP tools). MCP tool names include: %s.", len(mcpNames), boundedToolNames(mcpNames, 16))
	return b.String()
}

func boundedToolNames(names []string, max int) string {
	if len(names) == 0 {
		return "(none)"
	}
	if max <= 0 {
		max = 1
	}
	if len(names) <= max {
		return strings.Join(names, ", ")
	}
	return fmt.Sprintf("%s, ... +%d more", strings.Join(names[:max], ", "), len(names)-max)
}

// HandoffTask returns the original user task embedded in an executor handoff
// message, or s unchanged when it is not one. Session previews and auto-titles
// use it so dual-model sessions surface the user's words, not the handoff
// boilerplate (#3860).
func HandoffTask(s string) string {
	trimmed := strings.TrimSpace(s)
	if !strings.HasPrefix(trimmed, "# "+executorHandoffMarker) {
		return s
	}
	const header = "Original task:\n"
	_, after, ok := strings.Cut(trimmed, header)
	if !ok {
		return s
	}
	rest := after
	if j := strings.Index(rest, "\n\nPlanner output:"); j >= 0 {
		rest = rest[:j]
	}
	if task := strings.TrimSpace(rest); task != "" {
		return task
	}
	return s
}

// SetAsker gives both models the host's question surface. The planner needs it
// as much as the executor: a decision that shapes the plan must be settled
// while planning, not stapled to a finished plan.
func (c *Coordinator) SetAsker(as Asker) {
	if c == nil {
		return
	}
	if c.plannerAgent != nil {
		c.plannerAgent.SetAsker(as)
	}
	if c.executor != nil {
		c.executor.SetAsker(as)
	}
}