fix(hitl): complete HITL interrupt rendering pipeline for Go TUI

- Fix options format mismatch: normalize dict options to strings in
  component_mapper before sending to Go TUI select component
- Fix GraphInterrupt callback: suppress interrupt exceptions in
  protocol_callback so TUI shows checkmark instead of error icon
- Fix cancel/error resume: check action field in component_response
  before resuming graph, return None for cancel/error actions
- Fix Ctrl+C trapped: global ctrl+c handler fires before overlay
  component key interception, cancels active component first
- Fix inline flow text visibility: flush streamBuf to scrollback
  before rendering HITL component; collect flushed assistant message
  for tea.Println in TypeDone handler (was silently stored in state)
- Fix threshold slider invisible: auto-derive step=(max-min)/100
  when Python omits step field instead of failing Init
- Fix cell type selector Enter: Enter on last cluster auto-submits;
  on non-last clusters advances to next (like Tab)
- Improve ask_user tool docstring with component selection examples
- Bump version to 1.1.403

Author: cewinharhar

lobster-tui/internal/biocomp/celltype/celltype.go

@@ -125,8 +125,15 @@ func (c *CellTypeSelectorComponent) handleEditMode(km tea.KeyPressMsg) *biocomp.
 		c.exitEditMode()
 		return c.submitAll()
 	case "enter":
-		// Accept current input and exit edit mode.
+		// Accept current input. On the last cluster, auto-submit.
+		// On non-last clusters, move to the next one (like tab).
 		c.exitEditMode()
+		if c.cursor >= len(c.clusters)-1 {
+			return c.submitAll()
+		}
+		c.cursor++
+		c.adjustOffset()
+		c.enterEditMode()
 		return nil
 	default:
 		// Forward to the active textinput.

lobster-tui/internal/biocomp/threshold/threshold.go

@@ -42,7 +42,11 @@ func (c *ThresholdSliderComponent) Init(data json.RawMessage) error {
 		return fmt.Errorf("threshold_slider: min (%g) must be less than max (%g)", d.Min, d.Max)
 	}
 	if d.Step <= 0 {
-		return fmt.Errorf("threshold_slider: step must be positive, got %g", d.Step)
+		// Python mapper often omits step. Auto-derive a sensible default.
+		d.Step = (d.Max - d.Min) / 100
+		if d.Step <= 0 {
+			d.Step = 0.01
+		}
 	}
 	c.data = d
 	c.value = clamp(d.Default, d.Min, d.Max)

lobster-tui/internal/biocomp/threshold/threshold_test.go

@@ -79,19 +79,19 @@ func TestThresholdInitInvalid(t *testing.T) {
 		t.Error("expected error for min == max")
 	}
 
-	// Step <= 0
+	// Step <= 0 should auto-derive (not error) — Python mapper omits step.
 	data, _ = json.Marshal(map[string]any{
 		"label": "test", "min": 0.0, "max": 1.0, "step": 0.0, "default": 0.5,
 	})
-	if err := c.Init(data); err == nil {
-		t.Error("expected error for step <= 0")
+	if err := c.Init(data); err != nil {
+		t.Errorf("step=0 should auto-derive, got error: %v", err)
 	}
 
 	data, _ = json.Marshal(map[string]any{
 		"label": "test", "min": 0.0, "max": 1.0, "step": -0.1, "default": 0.5,
 	})
-	if err := c.Init(data); err == nil {
-		t.Error("expected error for negative step")
+	if err := c.Init(data); err != nil {
+		t.Errorf("step<0 should auto-derive, got error: %v", err)
 	}
 }
 

lobster-tui/internal/chat/content.go

@@ -127,3 +127,16 @@ func (m *Model) flushStreamBuffer() {
 	m.streamBuf.Reset()
 	m.appendBlock(BlockText{Text: text})
 }
+
+// collectLastAssistantMessage returns a single-element slice containing the
+// last assistant message, or nil if none exists. Used by the TypeDone handler
+// to feed inlinePrintMessagesCmd after flushStreamBuffer has put text into
+// m.messages in-place (which otherwise never gets tea.Println'd).
+func (m *Model) collectLastAssistantMessage() []ChatMessage {
+	for i := len(m.messages) - 1; i >= 0; i-- {
+		if m.messages[i].Role == "assistant" {
+			return []ChatMessage{m.messages[i]}
+		}
+	}
+	return nil
+}

lobster-tui/internal/chat/model.go

@@ -613,8 +613,10 @@ func (m Model) viewInline() tea.View {
 		b.WriteByte('\n')
 	}
 
-	// Inline BioComp component (rendered as a block above the composer).
-	if m.activeComponent != nil && m.activeComponent.Component.Mode() == "inline" {
+	// BioComp component (rendered as a block above the composer).
+	// In inline TUI mode, all components render inline regardless of their
+	// declared mode — there is no overlay layer to composite onto.
+	if m.activeComponent != nil {
 		comp := m.activeComponent.Component
 		inlineView, panicked := safeView(comp, m.width, m.height)
 		if panicked {
@@ -760,21 +762,35 @@ func (m Model) handleProtocol(msg protocolMsg) (tea.Model, tea.Cmd) {
 			return m, waitForProtocolMsg(m.handler)
 		}
 
+		if dp.Summary == "interrupt" {
+			// HITL interrupt: flush streamed text to scrollback so the
+			// supervisor's question is visible while the component renders.
+			// Do NOT clear tool feed or reset streaming state — the tool
+			// is still logically running (paused at interrupt).
+			m.flushStreamBuffer()
+			toPrint := m.collectLastAssistantMessage()
+			m.rebuildViewportWithMode(true)
+			printCmd := m.inlinePrintMessagesCmd(toPrint)
+			return m, tea.Batch(waitForProtocolMsg(m.handler), printCmd)
+		}
+
 		// Flush any remaining streamed text into typed blocks, then append
 		// buffered handoff lines that belong directly beneath the response.
 		m.flushStreamBuffer()
 
-		toAppend := make([]ChatMessage, 0, len(m.pendingHandoffs))
+		// Collect the finalized assistant message for printing. In inline
+		// flow mode, flushStreamBuffer puts text into m.messages in-place
+		// but nothing prints it to scrollback — we must do that explicitly.
+		toPrint := m.collectLastAssistantMessage()
 		if len(m.pendingHandoffs) > 0 {
-			toAppend = append(toAppend, m.pendingHandoffs...)
+			m.messages = append(m.messages, m.pendingHandoffs...)
+			toPrint = append(toPrint, m.pendingHandoffs...)
 			m.pendingHandoffs = m.pendingHandoffs[:0]
 		}
 		m.isStreaming = false
 		m.isCanceling = false
-		printCmd := m.appendMessages(toAppend, true)
-		if len(toAppend) == 0 {
-			m.rebuildViewportWithMode(true)
-		}
+		m.rebuildViewportWithMode(true)
+		printCmd := m.inlinePrintMessagesCmd(toPrint)
 		return m, tea.Batch(waitForProtocolMsg(m.handler), printCmd)
 
 	case protocol.TypeStatus:
@@ -1029,6 +1045,16 @@ func (m Model) handleKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
 		return m, mouseCaptureCmd(m.mouseCapture)
 	}
 
+	// Global keys that must ALWAYS work, even with an active component.
+	if msg.String() == "ctrl+c" && m.activeComponent != nil {
+		m.sendComponentResponse(m.activeComponent.MsgID, "cancel", map[string]any{"reason": "ctrl+c"})
+		m.activeComponent = nil
+		m.pendingChangeEvent = nil
+		m.changeDebounceActive = false
+		m.recalculateViewportHeight()
+		// Fall through to the normal ctrl+c handler below.
+	}
+
 	// Intercept keys for active BioComp overlay component.
 	if m.activeComponent != nil && m.activeComponent.Component.Mode() == "overlay" {
 		result, panicked := safeHandleMsg(m.activeComponent.Component, msg)
@@ -1912,17 +1938,25 @@ func (m Model) layoutReservedRowsLegacy() int {
 	if tf := renderToolFeed(m.toolFeed, m.styles, m.width, m.inline); tf != "" {
 		rows += lineCount(tf)
 	}
-	if m.activeComponent != nil && m.activeComponent.Component.Mode() == "inline" {
-		inlineView := m.activeComponent.Component.View(m.width, m.height)
-		if inlineView != "" {
-			rows += lineCount(inlineView)
+	if m.activeComponent != nil {
+		if m.inline {
+			// In inline mode, all components render as inline blocks.
+			inlineView := m.activeComponent.Component.View(m.width, m.height)
+			if inlineView != "" {
+				rows += lineCount(inlineView)
+			}
+		} else if m.activeComponent.Component.Mode() == "inline" {
+			inlineView := m.activeComponent.Component.View(m.width, m.height)
+			if inlineView != "" {
+				rows += lineCount(inlineView)
+			}
 		}
 	}
 	if m.progressActive {
 		rows += lineCount(renderProgressBar(m.progressLabel, m.progressCurrent, m.progressTotal, m.width, m.styles))
 	}
 
-	if m.activeComponent != nil && m.activeComponent.Component.Mode() == "overlay" {
+	if m.activeComponent != nil && m.activeComponent.Component.Mode() == "overlay" && !m.inline {
 		_, oh := biocomp.OverlaySize(m.width, m.height, "small")
 		rows += oh
 	} else if m.pendingConfirm != nil {
@@ -2048,9 +2082,25 @@ func (m *Model) recalculateComposerDimensions() {
 func (m *Model) recalculateComposerHeight() {
 	height := m.composerHeightForValue(m.input.Value())
 	if m.input.Height() == height {
+		// Height unchanged, but check if content fits and scroll is off.
+		if height > 0 && m.input.ScrollYOffset() > 0 {
+			totalVisual := m.composerHeightForValue(m.input.Value())
+			if totalVisual <= height {
+				m.input.MoveToBegin()
+				m.input.MoveToEnd()
+			}
+		}
 		return
 	}
 	m.input.SetHeight(height)
+	// When all content fits in the new height, reset scroll to show
+	// everything from the top. MoveToBegin zeroes the viewport offset;
+	// MoveToEnd restores the cursor to where the user is typing.
+	totalVisual := m.composerHeightForValue(m.input.Value())
+	if totalVisual <= height && m.input.ScrollYOffset() > 0 {
+		m.input.MoveToBegin()
+		m.input.MoveToEnd()
+	}
 }
 
 func (m Model) composerHeightForValue(value string) int {

lobster/cli_internal/go_tui_launcher.py

@@ -844,6 +844,11 @@ def _handle_user_query(
                 return
 
             # --- HITL interrupt: render component and await user response ---
+            # Flush any streamed text to scrollback BEFORE rendering the
+            # component so the supervisor's question is visible while the
+            # user interacts with the HITL widget.
+            bridge.send("done", {"summary": "interrupt"})
+
             response = _handle_interrupt(bridge, interrupt_event)
             if response is None:
                 # Interrupt was cancelled or timed out.
@@ -904,8 +909,14 @@ def _handle_interrupt(bridge: _LightBridge, interrupt_event: dict) -> Optional[d
                     "selected": payload.get("value", ""),
                     "index": payload.get("index", 0),
                 }
-            # component_response → pass through data
-            return payload.get("data", payload)
+            # component_response → check action before accepting.
+            data = payload.get("data", payload)
+            action = data.get("action", "submit") if isinstance(data, dict) else "submit"
+            if action in ("cancel", "error"):
+                # Component was cancelled or failed to render — don't resume
+                # the graph with garbage data.
+                return None
+            return data
 
         if resp_type == "quit":
             return None

lobster/services/interaction/component_mapper.py

@@ -60,10 +60,17 @@ def map_question(
     # Explicit options list -> select component.
     options = ctx.get("options")
     if isinstance(options, list) and len(options) > 0:
+        # Normalize dicts to strings — Go TUI select expects []string.
+        str_options = [
+            opt.get("label", opt.get("name", str(opt)))
+            if isinstance(opt, dict)
+            else str(opt)
+            for opt in options
+        ]
         return ComponentSelection(
             component="select",
-            data={"question": question, "options": options},
-            fallback_prompt=_build_select_fallback(question, options),
+            data={"question": question, "options": str_options},
+            fallback_prompt=_build_select_fallback(question, str_options),
         )
 
     # Cluster data -> cell_type_selector.

lobster/tools/user_interaction.py

@@ -28,7 +28,22 @@ def create_ask_user_tool(llm: Optional["BaseChatModel"] = None):
 
     @tool
     def ask_user(question: str, context: Optional[Dict[str, Any]] = None) -> str:
-        """Ask the user a clarification question. Renders an interactive component."""
+        """Pause execution and ask the user a question. Use ONLY when user input
+        is genuinely required (ambiguous intent, approval gate, or domain choice).
+        The question might come from a sub-agent that needs user input and asks you to provide this to them
+
+        Pass structured context for automatic component selection:
+          - {"options": ["A", "B", "C"]}        → dropdown select
+          - {"clusters": [{id, size, markers}]}  → cell-type annotation panel
+          - {"min": 0, "max": 1, "threshold": 0.05} → threshold slider
+          - (no context or confirm phrasing)     → yes/no or free-text
+
+        Args:
+            question: Clear, specific question for the user.
+            context: Structured hints for component selection (see above).
+
+        Returns:
+            JSON string with the user's response."""
         from langgraph.types import interrupt
 
         from lobster.services.interaction.component_mapper import map_question

lobster/ui/callbacks/protocol_callback.py

@@ -163,6 +163,29 @@ def on_tool_error(
         if tool_name == "unknown_tool":
             self.current_tool = None
             return
+
+        # GraphInterrupt/Interrupt is control flow (HITL interrupt), not an error.
+        # Emit as "complete" so the TUI shows ✓ instead of ✗.
+        # Check full MRO to catch subclasses (GraphInterrupt → GraphBubbleUp).
+        _interrupt_names = {"GraphInterrupt", "Interrupt", "GraphBubbleUp"}
+        error_mro = {cls.__name__ for cls in type(error).__mro__}
+        if _interrupt_names & error_mro:
+            self._emit(
+                "tool_execution",
+                {
+                    "tool": tool_name,
+                    "agent": (
+                        str(run_state.get("agent"))
+                        if run_state is not None
+                        else self.current_agent or "unknown"
+                    ),
+                    "status": "complete",
+                    "summary": "awaiting user input",
+                    "tool_call_id": run_key,
+                },
+            )
+            return
+
         self._emit(
             "tool_execution",
             {

lobster/version.py

@@ -1 +1 @@
-__version__ = "1.1.401"
+__version__ = "1.1.403"