test(runtime): fix ask_user CI regressions

Generated with [codeagent](https://github.com/qbox/codeagent)
Co-authored-by: Cai-Tang-www <106404101+Cai-Tang-www@users.noreply.github.com>

Author: xgopilot

internal/app/bootstrap_test.go

@@ -2087,6 +2087,10 @@ func (s *stubRemoteRuntimeForBootstrap) ResolvePermission(context.Context, servi
 	return nil
 }
 
+func (s *stubRemoteRuntimeForBootstrap) ResolveUserQuestion(context.Context, services.UserQuestionResolutionInput) error {
+	return nil
+}
+
 func (s *stubRemoteRuntimeForBootstrap) CancelActiveRun() bool {
 	return false
 }

internal/gateway/multi_workspace_runtime_test.go

@@ -24,6 +24,7 @@ type recordingPort struct {
 	runCalls          atomic.Int32
 	listSessionsCalls atomic.Int32
 	executeSysCalls   atomic.Int32
+	resolveUserCalls  atomic.Int32
 	cancelCalls       atomic.Int32
 	closed            atomic.Int32
 	closeOnce         sync.Once
@@ -81,6 +82,7 @@ func (p *recordingPort) ResolvePermission(_ context.Context, _ PermissionResolut
 }
 
 func (p *recordingPort) ResolveUserQuestion(_ context.Context, _ UserQuestionAnswerInput) error {
+	p.resolveUserCalls.Add(1)
 	return nil
 }
 
@@ -467,6 +469,28 @@ func TestMultiWorkspaceRuntime_SwitchWorkspaceValidates(t *testing.T) {
 	}
 }
 
+func TestMultiWorkspaceRuntime_ResolveUserQuestionRoutesByWorkspace(t *testing.T) {
+	idx, alpha, beta := setupIndex(t)
+	builder := newTestBuilder()
+	mw := NewMultiWorkspaceRuntime(idx, alpha.Hash, builder.build)
+	t.Cleanup(func() { _ = mw.Close() })
+
+	if err := mw.ResolveUserQuestion(ctxWithHash(t, beta.Hash), UserQuestionAnswerInput{
+		RequestID: "ask-1",
+		Status:    "answered",
+	}); err != nil {
+		t.Fatalf("ResolveUserQuestion: %v", err)
+	}
+
+	betaPort := builder.portFor(beta.Path)
+	if betaPort == nil {
+		t.Fatalf("beta port should be built")
+	}
+	if got := betaPort.resolveUserCalls.Load(); got != 1 {
+		t.Fatalf("beta resolve user calls = %d, want 1", got)
+	}
+}
+
 func TestMultiWorkspaceRuntime_CreatePersistsIndex(t *testing.T) {
 	idx, alpha, _ := setupIndex(t)
 	builder := newTestBuilder()

internal/gateway/validate_additional_test.go

@@ -137,3 +137,46 @@ func TestValidateResolvePermissionInvalidPayloadType(t *testing.T) {
 		t.Fatalf("error code = %q, want %q", err.Code, ErrorCodeInvalidAction.String())
 	}
 }
+
+func TestDecodeUserQuestionAnswerPayloadAdditionalBranches(t *testing.T) {
+	t.Parallel()
+
+	t.Run("direct struct", func(t *testing.T) {
+		input, err := decodeUserQuestionAnswerPayload(UserQuestionAnswerInput{
+			RequestID: "ask-1",
+			Status:    "answered",
+		})
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if input.RequestID != "ask-1" {
+			t.Fatalf("request id = %q, want ask-1", input.RequestID)
+		}
+	})
+
+	t.Run("nil pointer", func(t *testing.T) {
+		var input *UserQuestionAnswerInput
+		decoded, err := decodeUserQuestionAnswerPayload(input)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if decoded.RequestID != "" || decoded.Status != "" {
+			t.Fatalf("expected zero value from nil pointer, got %#v", decoded)
+		}
+	})
+
+	t.Run("marshal error", func(t *testing.T) {
+		payload := map[string]any{"bad": func() {}}
+		_, err := decodeUserQuestionAnswerPayload(payload)
+		if err == nil {
+			t.Fatal("expected marshal error")
+		}
+	})
+
+	t.Run("unmarshal error", func(t *testing.T) {
+		_, err := decodeUserQuestionAnswerPayload([]byte("not-json-object"))
+		if err == nil {
+			t.Fatal("expected unmarshal error")
+		}
+	})
+}

internal/runtime/ask_user_test.go

@@ -172,6 +172,61 @@ func TestResolveUserQuestionSkip(t *testing.T) {
 	}
 }
 
+func TestResolveUserQuestionDefaultsStatusAndTrimsMessage(t *testing.T) {
+	t.Parallel()
+
+	service := NewWithFactory(
+		newRuntimeConfigManager(t),
+		&stubToolManager{},
+		newMemoryStore(),
+		&scriptedProviderFactory{provider: &scriptedProvider{}},
+		nil,
+	)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	var openResult askuser.Result
+	var openErr error
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		_, openResult, openErr = service.askUserBroker.Open(ctx, askuser.Request{
+			QuestionID: "q1",
+			TimeoutSec: 10,
+		})
+	}()
+
+	time.Sleep(50 * time.Millisecond)
+
+	ids := service.askUserBroker.PendingIDs()
+	if len(ids) != 1 {
+		t.Fatalf("expected 1 pending request, got %d", len(ids))
+	}
+
+	resolveErr := service.ResolveUserQuestion(context.Background(), UserQuestionResolutionInput{
+		RequestID: ids[0],
+		Message:   "  keep this trimmed  ",
+	})
+	if resolveErr != nil {
+		t.Fatalf("ResolveUserQuestion default status error: %v", resolveErr)
+	}
+
+	wg.Wait()
+
+	if openErr != nil {
+		t.Fatalf("broker Open error: %v", openErr)
+	}
+	if openResult.Status != askuser.StatusAnswered {
+		t.Fatalf("expected default answered status, got %q", openResult.Status)
+	}
+	if openResult.Message != "keep this trimmed" {
+		t.Fatalf("expected trimmed message, got %q", openResult.Message)
+	}
+}
+
 func TestResolveUserQuestionContextCanceled(t *testing.T) {
 	t.Parallel()
 
@@ -195,6 +250,24 @@ func TestResolveUserQuestionContextCanceled(t *testing.T) {
 	}
 }
 
+func TestEventTypeFromAskUserEvent(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]EventType{
+		"user_question_requested": EventUserQuestionRequested,
+		"user_question_answered":  EventUserQuestionAnswered,
+		"user_question_skipped":   EventUserQuestionSkipped,
+		"user_question_timeout":   EventUserQuestionTimeout,
+		"unknown":                 EventError,
+	}
+
+	for name, want := range tests {
+		if got := eventTypeFromAskUserEvent(name); got != want {
+			t.Fatalf("eventTypeFromAskUserEvent(%q) = %q, want %q", name, got, want)
+		}
+	}
+}
+
 func TestAskUserBrokerAdapterConversion(t *testing.T) {
 	t.Parallel()
 
@@ -255,3 +328,38 @@ func TestAskUserBrokerAdapterConversion(t *testing.T) {
 
 	wg.Wait()
 }
+
+func TestAskUserBrokerAdapterErrorAndOptionConversion(t *testing.T) {
+	t.Parallel()
+
+	broker := askuser.NewBroker()
+	adapter := newAskUserBrokerAdapter(broker)
+
+	if got := convertAskUserOptions(nil); got != nil {
+		t.Fatalf("expected nil options conversion, got %#v", got)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	requestID, result, err := adapter.Open(ctx, tools.AskUserRequest{
+		QuestionID: "adapter-q2",
+		Title:      "Choose",
+		Kind:       "single_choice",
+		Options: []tools.AskUserOption{
+			{Label: "A", Description: "first"},
+		},
+	})
+	if err == nil {
+		t.Fatal("expected adapter Open error when context is canceled")
+	}
+	if !strings.Contains(err.Error(), "canceled") {
+		t.Fatalf("expected canceled error, got %v", err)
+	}
+	if requestID == "" {
+		t.Fatal("expected generated request_id on canceled adapter Open")
+	}
+	if result.Status != askuser.StatusTimeout {
+		t.Fatalf("expected timeout status on canceled adapter Open, got %q", result.Status)
+	}
+}

internal/tools/ask_user_tool_test.go

@@ -6,6 +6,8 @@ import (
 	"errors"
 	"strings"
 	"testing"
+
+	"neo-code/internal/security"
 )
 
 // stubAskUserBroker implements AskUserBroker for tests.
@@ -481,3 +483,29 @@ func TestAskUserToolVisibleInReadOnlyMode(t *testing.T) {
 		t.Fatal("expected ask_user to be visible in read-only plan mode")
 	}
 }
+
+func TestIsReadOnlyActionAllowedIncludesInteractionAndTodoWrite(t *testing.T) {
+	t.Parallel()
+
+	if !isReadOnlyActionAllowed(security.Action{Type: security.ActionTypeInteraction}) {
+		t.Fatal("expected interaction action to be allowed in read-only mode")
+	}
+
+	if !isReadOnlyActionAllowed(security.Action{
+		Type: security.ActionTypeWrite,
+		Payload: security.ActionPayload{
+			Operation: "  " + ToolNameTodoWrite + "  ",
+		},
+	}) {
+		t.Fatal("expected todo_write action to be allowed in read-only mode")
+	}
+
+	if isReadOnlyActionAllowed(security.Action{
+		Type: security.ActionTypeWrite,
+		Payload: security.ActionPayload{
+			Operation: ToolNameBash,
+		},
+	}) {
+		t.Fatal("expected non-todo write action to be blocked in read-only mode")
+	}
+}