The kernel carried RunnableAgent.Phases as a DTO but never executed it —
Run always ran a single agent loop with ra.SystemPrompt, so a phased agent
(mort's deepresearch/research) silently ran one loop with the base prompt
instead of its pipeline. This implements the phase loop, ported from mort's
agentexec pipeline but reusing the kernel's own machinery.

- run/phases.go: runPhases / runOnePhase. Phases run sequentially; each is a
  fresh agent loop (or a bare LLM call for IsRunFunc phases) with its own
  template-expanded system prompt ({{.Query}} + {{.<PhaseName>}}), model
  tier, step cap, and tool subset. Outputs thread into later phases; the
  final phase's output is the run output. Optional phases swallow errors and
  substitute FallbackMessage; a non-optional phase that merely exhausts its
  step/tool budget salvages its partial transcript and continues (a hard
  error still aborts); per-phase tier-resolve failures fall back with a WARN.
- run/agent.go: Phase gains IsRunFunc + FallbackMessage (the kernel Phase
  struct previously omitted them).
- run/executor.go: Run factors the shared agent options (tool-error limits,
  step observer, compactor) and branches — single loop (critic's dynamic
  step ceiling) vs the phase runner (fixed per-phase caps; the run-level
  critic's steer + hard deadline still apply across phases). systemPrompt
  now delegates to systemPromptWithBody so each phase keeps the platform
  header. The same step observer feeds audit/steps/critic across all phases.

Tests (run/phases_test.go): sequential output threading + template
expansion, Optional-failure → FallbackMessage continues, hard-error abort,
IsRunFunc bare call, per-phase SystemHeader, filterToolbox subset, template
expansion. Full ./... suite green.

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>

@@ -0,0 +43,4 @@
+// critic's dynamic iteration ceiling (per-phase caps are fixed at phase start —
+// the run-level critic's steer + hard deadline still apply across phases).
+
+// phaseDeps carries the per-run state the phase runner shares with Run: the base

@@ -0,0 +49,4 @@
+// the critic/session steer, and the audit recorder (phase events).
+type phaseDeps struct {
+	baseModel   llm.Model
+	baseTier    string

@@ -0,0 +61,4 @@
+// whose Output is the final phase's output, with Usage aggregated across phases
+// and Messages set to the last phase's transcript (for the PostRun hook). A hard
+// (non-optional, non-budget) phase failure returns the error.
+func (e *Executor) runPhases(runCtx context.Context, ra RunnableAgent, deps phaseDeps, query string, images []llm.ImagePart) (*agent.Result, error) {

@@ -0,0 +73,4 @@
+			return lastResult, err
+		}
+
+		instructions := expandPhaseTemplate(phase.SystemPrompt, query, outputs)

@@ -0,0 +86,4 @@
+		if err != nil {
+			isLast := i == len(ra.Phases)-1
+			switch {
+			case phase.Optional:

@@ -0,0 +97,4 @@
+					deps.rec.LogEvent("phase_failed_optional", map[string]any{"phase": phase.Name, "error": err.Error()})
+				}
+
+			case isPhaseBudgetExhaustion(err) && (!isLast || strings.TrimSpace(output) != ""):

@@ -0,0 +115,4 @@
+				}
+
+			default:
+				return lastResult, fmt.Errorf("pipeline phase %q: %w", phase.Name, err)

@@ -0,0 +125,4 @@
+
+	// Synthesize the run result: the final phase's output, usage aggregated over
+	// all phases, and the last phase's transcript for the PostRun hook.
+	if lastResult == nil {

@@ -0,0 +140,4 @@
+func (e *Executor) runOnePhase(runCtx context.Context, ra RunnableAgent, deps phaseDeps, phase Phase, instructions, query string, images []llm.ImagePart) (string, *agent.Result, error) {
+	model := e.phaseModel(runCtx, deps, ra, phase)
+	// The phase's expanded instructions are the system prompt (with the platform
+	// header so tools keep their run ids); the original query is the user message.

@@ -0,0 +152,4 @@
+			return "", nil, fmt.Errorf("phase %q model call: %w", phase.Name, err)
+		}
+		if deps.rec != nil {
+			deps.rec.OnStep(1, resp)

@@ -0,0 +183,4 @@
+	// Budget/guard exhaustion leaves a usable partial transcript but an empty
+	// final answer; salvage the narrated work so the pipeline can carry it forward.
+	if runErr != nil && isPhaseBudgetExhaustion(runErr) {
+		if salvaged := salvagePhaseTranscript(res); salvaged != "" {

@@ -0,0 +196,4 @@
+	if phase.ModelTier == "" {
+		return deps.baseModel
+	}
+	_, m, err := e.cfg.Models(ctx, phase.ModelTier)

@@ -0,0 +209,4 @@
+// loop hit its step cap or tripped a tool-error guard) — which leaves a usable
+// partial transcript — as opposed to a hard error (cancellation, model failure).
+func isPhaseBudgetExhaustion(err error) bool {
+	return errors.Is(err, agent.ErrMaxSteps) || errors.Is(err, agent.ErrToolLoop)

@@ -0,0 +232,4 @@
+		}
+	}
+	out := strings.TrimSpace(b.String())
+	const maxSalvage = 8000

@@ -0,0 +241,4 @@
+
+// phaseUserMessage builds a phase's user message: the original query text plus
+// any inline images. Mirrors the single-loop multimodal seeding in runAgent.
+func phaseUserMessage(query string, images []llm.ImagePart) llm.Message {

@@ -0,0 +257,4 @@
+
+// expandPhaseTemplate applies Go text/template substitution to a phase prompt,
+// replacing {{.Query}} with the original query and {{.<PhaseName>}} with a prior
+// phase's output. Returns the original string unchanged if parsing or execution

@@ -0,0 +264,4 @@
+	if err != nil {
+		return tmpl
+	}
+	data := map[string]string{"Query": query}

@@ -0,0 +280,4 @@
+// a WARN — a typo'd phase tool list should not abort a run mid-pipeline.
+func filterToolbox(box *llm.Toolbox, names []string) *llm.Toolbox {
+	out := llm.NewToolbox(box.Name())
+	if len(names) == 0 {

@@ -0,0 +301,4 @@
+
+// addUsage sums two llm.Usage tallies field-by-field so a phased run reports the
+// total tokens across all phases.
+func addUsage(a, b llm.Usage) llm.Usage {