TUI: add FollowupBehavior setting to choose between steer and follow-up dispatch

pkg/app/app.go

@@ -340,6 +340,64 @@ func (a *App) Run(ctx context.Context, cancel context.CancelFunc, message string
 	}()
 }
 
+// buildQueuedMessage processes a text/attachment pair into a runtime.QueuedMessage
+// suitable for either steering or follow-up. Attachments are rendered into
+// MultiContent parts so the model can see images/PDFs alongside the text.
+func (a *App) buildQueuedMessage(content string, attachments []messages.Attachment) runtime.QueuedMessage {
+	msg := runtime.QueuedMessage{Content: content}
+
+	if len(attachments) == 0 {
+		return msg
+	}
+
+	ctx := context.Background()
+	var textBuilder strings.Builder
+	textBuilder.WriteString(content)
+
+	var binaryParts []chat.MessagePart
+
+	for _, att := range attachments {
+		switch {
+		case att.FilePath != "":
+			a.processFileAttachment(ctx, att, &textBuilder, &binaryParts)
+		case att.Content != "":
+			a.processInlineAttachment(att, &textBuilder)
+		default:
+			slog.Debug("skipping attachment with no file path or content", "name", att.Name)
+		}
+	}
+
+	msg.Content = textBuilder.String()
+	if len(binaryParts) > 0 {
+		msg.MultiContent = binaryParts
+	}
+	return msg
+}
+
+// Steer enqueues a user message for mid-turn injection into the running agent
+// loop. The agent will see the message at the next tool-round boundary. Returns
+// an error if the steer queue is full.
+func (a *App) Steer(content string, attachments []messages.Attachment) error {
+	return a.runtime.Steer(a.buildQueuedMessage(content, attachments))
+}
+
+// ClearSteerQueue drains all pending messages from the runtime's steer queue.
+func (a *App) ClearSteerQueue() {
+	a.runtime.ClearSteerQueue()
+}
+
+// FollowUp enqueues a user message for end-of-turn processing. Each follow-up
+// gets a full undivided agent turn after the current turn completes. Returns
+// an error if the follow-up queue is full.
+func (a *App) FollowUp(content string, attachments []messages.Attachment) error {
+	return a.runtime.FollowUp(a.buildQueuedMessage(content, attachments))
+}
+
+// ClearFollowUpQueue drains all pending messages from the runtime's follow-up queue.
+func (a *App) ClearFollowUpQueue() {
+	a.runtime.ClearFollowUpQueue()
+}
+
 // processFileAttachment reads a file from disk, classifies it, and either
 // appends its text content to textBuilder or adds a binary part to binaryParts.
 func (a *App) processFileAttachment(ctx context.Context, att messages.Attachment, textBuilder *strings.Builder, binaryParts *[]chat.MessagePart) {

pkg/app/app_test.go

@@ -68,7 +68,9 @@ func (m *mockRuntime) TitleGenerator() *sessiontitle.Generator { return nil }
 func (m *mockRuntime) Close() error                            { return nil }
 func (m *mockRuntime) Stop()                                   {}
 func (m *mockRuntime) Steer(_ runtime.QueuedMessage) error     { return nil }
+func (m *mockRuntime) ClearSteerQueue()                        {}
 func (m *mockRuntime) FollowUp(_ runtime.QueuedMessage) error  { return nil }
+func (m *mockRuntime) ClearFollowUpQueue()                     {}
 
 // Verify mockRuntime implements runtime.Runtime
 var _ runtime.Runtime = (*mockRuntime)(nil)

pkg/cli/runner_test.go

@@ -61,7 +61,9 @@ func (m *mockRuntime) UpdateSessionTitle(context.Context, *session.Session, stri
 func (m *mockRuntime) TitleGenerator() *sessiontitle.Generator                               { return nil }
 func (m *mockRuntime) Close() error                                                          { return nil }
 func (m *mockRuntime) Steer(runtime.QueuedMessage) error                                     { return nil }
+func (m *mockRuntime) ClearSteerQueue()                                                      {}
 func (m *mockRuntime) FollowUp(runtime.QueuedMessage) error                                  { return nil }
+func (m *mockRuntime) ClearFollowUpQueue()                                                   {}
 func (m *mockRuntime) RegenerateTitle(context.Context, *session.Session, chan runtime.Event) {}
 
 func (m *mockRuntime) Resume(_ context.Context, req runtime.ResumeRequest) {

pkg/runtime/commands_test.go

@@ -70,7 +70,9 @@ func (m *mockRuntime) UpdateSessionTitle(context.Context, *session.Session, stri
 func (m *mockRuntime) TitleGenerator() *sessiontitle.Generator { return nil }
 func (m *mockRuntime) Close() error                            { return nil }
 func (m *mockRuntime) Steer(QueuedMessage) error               { return nil }
+func (m *mockRuntime) ClearSteerQueue()                        {}
 func (m *mockRuntime) FollowUp(QueuedMessage) error            { return nil }
+func (m *mockRuntime) ClearFollowUpQueue()                     {}
 
 func (m *mockRuntime) RegenerateTitle(context.Context, *session.Session, chan Event) {
 }

pkg/runtime/loop.go

@@ -75,6 +75,13 @@ func (r *LocalRuntime) RunStream(ctx context.Context, sess *session.Session) <-c
 	events := make(chan Event, 128)
 
 	go func() {
+		// Drain any orphaned messages from a previous cancelled run so
+		// they don't leak into this new stream. Both queues are drained:
+		// the user may have switched modes between sessions, or pending
+		// messages of either kind may have survived a cancel boundary.
+		r.steerQueue.Drain(context.Background())
+		r.followUpQueue.Drain(context.Background())
+
 		telemetry.RecordSessionStart(ctx, r.CurrentAgentName(), sess.ID)
 
 		ctx, sessionSpan := r.startSpan(ctx, "runtime.session", trace.WithAttributes(

pkg/runtime/remote_runtime.go

@@ -222,6 +222,14 @@ func (r *RemoteRuntime) Steer(msg QueuedMessage) error {
 	})
 }
 
+// ClearSteerQueue is a no-op for remote runtimes — steered messages are
+// forwarded to the server and there is no local queue to drain.
+func (r *RemoteRuntime) ClearSteerQueue() {}
+
+// ClearFollowUpQueue is a no-op for remote runtimes — follow-up messages are
+// forwarded to the server and there is no local queue to drain.
+func (r *RemoteRuntime) ClearFollowUpQueue() {}
+
 // FollowUp enqueues a message for end-of-turn processing on the remote server.
 func (r *RemoteRuntime) FollowUp(msg QueuedMessage) error {
 	if r.sessionID == "" {

pkg/runtime/runtime.go

@@ -143,9 +143,15 @@ type Runtime interface {
 	// running agent loop. Returns an error if the queue is full or steering
 	// is not available.
 	Steer(msg QueuedMessage) error
+	// ClearSteerQueue drains all pending messages from the steer queue,
+	// discarding them. Used when the user explicitly clears the queue.
+	ClearSteerQueue()
 	// FollowUp enqueues a message for end-of-turn processing. Each follow-up
 	// gets a full undivided agent turn. Returns an error if the queue is full.
 	FollowUp(msg QueuedMessage) error
+	// ClearFollowUpQueue drains all pending messages from the follow-up queue,
+	// discarding them. Used when the user explicitly clears the queue.
+	ClearFollowUpQueue()
 
 	// Close releases resources held by the runtime (e.g., session store connections).
 	Close() error
@@ -1059,6 +1065,12 @@ func (r *LocalRuntime) Steer(msg QueuedMessage) error {
 	return nil
 }
 
+// ClearSteerQueue drains all pending messages from the steer queue,
+// discarding them. This is safe to call concurrently with the agent loop.
+func (r *LocalRuntime) ClearSteerQueue() {
+	r.steerQueue.Drain(context.Background())
+}
+
 // FollowUp enqueues a message to be processed after the current agent turn
 // finishes. Unlike Steer, follow-ups are popped one at a time and each gets
 // a full undivided agent turn.
@@ -1069,6 +1081,12 @@ func (r *LocalRuntime) FollowUp(msg QueuedMessage) error {
 	return nil
 }
 
+// ClearFollowUpQueue drains all pending messages from the follow-up queue,
+// discarding them. This is safe to call concurrently with the agent loop.
+func (r *LocalRuntime) ClearFollowUpQueue() {
+	r.followUpQueue.Drain(context.Background())
+}
+
 // Run starts the agent's interaction loop
 
 func (r *LocalRuntime) startSpan(ctx context.Context, name string, opts ...trace.SpanStartOption) (context.Context, trace.Span) {

pkg/tui/commands/commands.go

@@ -313,6 +313,17 @@ func builtInSettingsCommands() []Item {
 				return core.CmdHandler(messages.OpenThemePickerMsg{})
 			},
 		},
+		{
+			ID:           "settings.followup-behavior",
+			Label:        "Follow-up Behavior",
+			SlashCommand: "/followup-behavior",
+			Description:  "Set behavior for messages sent while agent is working (usage: /followup-behavior steer|followup)",
+			Category:     "Settings",
+			Immediate:    true,
+			Execute: func(arg string) tea.Cmd {
+				return core.CmdHandler(messages.SetFollowupBehaviorMsg{Mode: strings.TrimSpace(arg)})
+			},
+		},
 	}
 }
 

pkg/tui/handlers.go

@@ -351,6 +351,61 @@ func (m *appModel) handleToggleSplitDiff() (tea.Model, tea.Cmd) {
 	return m, tea.Batch(cmds...)
 }
 
+// handleSetFollowupBehavior sets the follow-up behavior persistently. When
+// called with an empty mode it reports the current value. Invalid modes
+// produce a warning notification listing the accepted values.
+func (m *appModel) handleSetFollowupBehavior(mode string) (tea.Model, tea.Cmd) {
+	mode = strings.ToLower(strings.TrimSpace(mode))
+
+	current := userconfig.Get().GetFollowupBehavior()
+	if mode == "" {
+		return m, notification.InfoCmd(fmt.Sprintf(
+			"Follow-up behavior: %s · usage: /followup-behavior steer|followup", current))
+	}
+
+	if mode != userconfig.FollowupBehaviorSteer && mode != userconfig.FollowupBehaviorFollowUp {
+		return m, notification.WarningCmd(fmt.Sprintf(
+			"Unknown follow-up behavior %q. Valid values: %s, %s",
+			mode, userconfig.FollowupBehaviorSteer, userconfig.FollowupBehaviorFollowUp))
+	}
+
+	if mode == current {
+		return m, notification.InfoCmd(fmt.Sprintf("Follow-up behavior already set to %q", mode))
+	}
+
+	// Apply the change in-memory synchronously so userconfig.Get returns the
+	// new value immediately. Without this the send-dispatch and
+	// working-indicator readers below would race the background file write
+	// and keep returning the old mode until it commits — meaning a message
+	// sent right after the command could be dispatched under the old mode.
+	userconfig.SetFollowupBehaviorOverride(mode)
+
+	// Persist to global userconfig (fire-and-forget, matching the split-diff pattern).
+	go func() {
+		cfg, err := userconfig.Load()
+		if err != nil {
+			slog.Warn("Failed to load userconfig for follow-up behavior change", "error", err)
+			return
+		}
+		if cfg.Settings == nil {
+			cfg.Settings = &userconfig.Settings{}
+		}
+		cfg.Settings.FollowupBehavior = mode
+		if err := cfg.Save(); err != nil {
+			slog.Warn("Failed to persist follow-up behavior to userconfig", "error", err)
+		}
+	}()
+
+	var description string
+	switch mode {
+	case userconfig.FollowupBehaviorSteer:
+		description = "messages sent while working will be injected mid-turn"
+	case userconfig.FollowupBehaviorFollowUp:
+		description = "messages sent while working will queue as their own turn"
+	}
+	return m, notification.SuccessCmd(fmt.Sprintf("Follow-up behavior set to %q · %s", mode, description))
+}
+
 // --- Dialogs ---
 
 func (m *appModel) handleShowCostDialog() (tea.Model, tea.Cmd) {

pkg/tui/messages/session.go

@@ -80,6 +80,12 @@ type (
 	// ToggleSplitDiffMsg toggles split diff view mode.
 	ToggleSplitDiffMsg struct{}
 
+	// SetFollowupBehaviorMsg sets the follow-up behavior (how messages
+	// submitted while the agent is working are dispatched). Mode is the raw
+	// user-supplied value; empty string means "show current value". Unknown
+	// values are rejected by the handler.
+	SetFollowupBehaviorMsg struct{ Mode string }
+
 	// SendMsg contains the content sent to the agent.
 	SendMsg struct {
 		Content     string       // Full content sent to the agent (with file contents expanded)