From 2a182d7f17661ebf8436fe6f3bd5b347b13c79f5 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 13 Nov 2026 16:47:41 +0000 Subject: [PATCH 1/2] Stop background tasks separately from chat turns Keep Esc and /stop scoped to the foreground turn while exposing an explicit stop-tasks operation for supported chat backends. Add the protocol, server routing, app command, and coverage for task stopping and unsupported harnesses. --- .../chat/conversation/chat_composer_bar.dart | 13 +++++ .../chat_composer_controller.dart | 11 ++++ .../features/chat/data/chat_repository.dart | 5 ++ .../features/chat/domain/chat_commands.dart | 6 +++ .../chat_command_palette_test.dart | 29 +++++++++++ .../chat_composer_bar_fixtures.dart | 8 +++ .../chat/domain/chat_commands_test.dart | 3 ++ internal/claude/chat.go | 38 ++++++++++++++ internal/claude/claude_test.go | 51 +++++++++++++++++++ internal/claude/testdata/fake-claude.py | 5 ++ internal/codex/chat.go | 4 ++ internal/opencode/chat.go | 20 ++++++++ internal/opencode/chat_test.go | 36 +++++++++++++ internal/protocol/chat.go | 10 ++++ internal/protocol/message.go | 5 +- internal/server/chat.go | 7 +++ internal/server/chat_manager.go | 12 +++++ internal/server/chat_stop_tasks.go | 39 ++++++++++++++ internal/server/chat_test.go | 31 +++++++++++ 19 files changed, 331 insertions(+), 2 deletions(-) create mode 100644 internal/server/chat_stop_tasks.go diff --git a/app/lib/features/chat/conversation/chat_composer_bar.dart b/app/lib/features/chat/conversation/chat_composer_bar.dart index fc7e9671..35899d97 100644 --- a/app/lib/features/chat/conversation/chat_composer_bar.dart +++ b/app/lib/features/chat/conversation/chat_composer_bar.dart @@ -596,6 +596,9 @@ class _ChatComposerBarState extends State { } else { _showCommandNotice('No turn is running in this chat.', failed: true); } + } else if (command.name == chatCommandStopTasks) { + _consumeCommandDraft(); + unawaited(_stopTasksFromCommand()); } else if (command.name == chatCommandHelp) { _consumeCommandDraft(); _showCommandNotice(chatCommandHelpText()); @@ -624,6 +627,16 @@ class _ChatComposerBarState extends State { _showCommandNotice(chatStopCommandNotice); } + Future _stopTasksFromCommand() async { + try { + if (mounted) { + _showCommandNotice(await widget.composer.stopTasks()); + } + } catch (error) { + if (mounted) _showCommandNotice('$error', failed: true); + } + } + void _consumeCommandDraft() { _text.clear(); unawaited(widget.composer.setDraft('')); diff --git a/app/lib/features/chat/conversation/chat_composer_controller.dart b/app/lib/features/chat/conversation/chat_composer_controller.dart index 83645a68..2aa16802 100644 --- a/app/lib/features/chat/conversation/chat_composer_controller.dart +++ b/app/lib/features/chat/conversation/chat_composer_controller.dart @@ -373,6 +373,17 @@ class ChatComposerController extends ChangeNotifier { } } + /// Stops background tasks without interrupting the current turn. + Future stopTasks() async { + final reply = await _repository.stopTasks(sessionId); + final result = reply['chat_stop_tasks']; + if (result is Map) { + final message = '${result['message'] ?? ''}'.trim(); + if (message.isNotEmpty) return message; + } + return 'Background tasks stop request accepted.'; + } + /// Follows the server's queue report: a prompt it lists is the server's /// (any stored device copy is dropped) and shows "Queued"; one that left /// the queue shows what happened to it. diff --git a/app/lib/features/chat/data/chat_repository.dart b/app/lib/features/chat/data/chat_repository.dart index e99d6497..4f0f5741 100644 --- a/app/lib/features/chat/data/chat_repository.dart +++ b/app/lib/features/chat/data/chat_repository.dart @@ -272,6 +272,11 @@ class ChatRepository { 'chat_query': {'session_id': sessionId}, }); + Future stopTasks(String sessionId) => + gateway.call('chat_stop_tasks', { + 'chat_query': {'session_id': sessionId}, + }); + /// Removes one prompt the server still holds in the session's queue. The /// reply's `chat_queue` is the queue afterwards; a prompt already handed to /// the harness is refused. diff --git a/app/lib/features/chat/domain/chat_commands.dart b/app/lib/features/chat/domain/chat_commands.dart index 14f4f508..c4fafe3f 100644 --- a/app/lib/features/chat/domain/chat_commands.dart +++ b/app/lib/features/chat/domain/chat_commands.dart @@ -25,6 +25,7 @@ const String chatCommandNew = 'new'; const String chatCommandClose = 'close'; const String chatCommandRename = 'rename'; const String chatCommandStop = 'stop'; +const String chatCommandStopTasks = 'stop_tasks'; const String chatCommandHelp = 'help'; /// The recorded command list, in the order the palette shows it. @@ -50,6 +51,11 @@ const List chatCommands = [ summary: 'Stop the turn that is running', usage: '/stop', ), + ChatCommand( + name: chatCommandStopTasks, + summary: 'Stop all background tasks in this chat', + usage: '/stop_tasks', + ), ChatCommand( name: chatCommandHelp, summary: 'List every command', diff --git a/app/test/features/chat/conversation/chat_command_palette_test.dart b/app/test/features/chat/conversation/chat_command_palette_test.dart index a0c853d5..3cf7099a 100644 --- a/app/test/features/chat/conversation/chat_command_palette_test.dart +++ b/app/test/features/chat/conversation/chat_command_palette_test.dart @@ -249,6 +249,7 @@ void main() { '/close — Finish this session for every client, keeping its history\n' '/rename — Rename this session\n' '/stop — Stop the turn that is running\n' + '/stop_tasks — Stop all background tasks in this chat\n' '/help — List every command\n' '!<command> — Run a shell command in this chat’s folder; ' 'the agent does not see it unless you send it', @@ -294,6 +295,34 @@ void main() { variant: _desktop, ); + testWidgets( + '/stop_tasks stops background tasks without interrupting the turn', + (tester) async { + gateway.stopTasks = () async => { + 'chat_stop_tasks': { + 'stopped': 2, + 'message': 'Stopped background tasks.', + }, + }; + await pumpComposer(tester); + await tester.enterText( + find.byKey(const Key('chat-composer-field')), + '/stop_tasks', + ); + await tester.pump(); + await tester.sendKeyEvent(LogicalKeyboardKey.enter); + await tester.pumpAndSettle(); + + expect(gateway.stopTasksBodies, [ + <String, dynamic>{'session_id': 's'}, + ]); + expect(gateway.interruptBodies, isEmpty); + expect(gateway.promptBodies, isEmpty); + expect(find.text('Stopped background tasks.'), findsOneWidget); + }, + variant: _desktop, + ); + testWidgets('/stop interrupts the current session through the composer', ( tester, ) async { diff --git a/app/test/features/chat/conversation/chat_composer_bar_fixtures.dart b/app/test/features/chat/conversation/chat_composer_bar_fixtures.dart index 0c1cb731..75161b49 100644 --- a/app/test/features/chat/conversation/chat_composer_bar_fixtures.dart +++ b/app/test/features/chat/conversation/chat_composer_bar_fixtures.dart @@ -16,6 +16,7 @@ class ComposerBarGateway implements ApiGateway { JsonMap page = chatPage(const []); Future<JsonMap> Function(String text, String operationId)? prompt; Future<JsonMap> Function()? interrupt; + Future<JsonMap> Function()? stopTasks; @override Future<JsonMap> call(String type, [JsonMap fields = const {}]) async { @@ -32,6 +33,8 @@ class ComposerBarGateway implements ApiGateway { : prompt!('${body['text'] ?? ''}', '${body['operation_id'] ?? ''}'); case 'chat_interrupt': return interrupt == null ? <String, dynamic>{} : interrupt!(); + case 'chat_stop_tasks': + return stopTasks == null ? <String, dynamic>{} : stopTasks!(); } return <String, dynamic>{}; } @@ -49,6 +52,11 @@ class ComposerBarGateway implements ApiGateway { .map((call) => call.fields['chat_query'] as JsonMap) .toList(); + List<JsonMap> get stopTasksBodies => calls + .where((call) => call.type == 'chat_stop_tasks') + .map((call) => call.fields['chat_query'] as JsonMap) + .toList(); + void emitEvent(JsonMap body) => _frames.add({'type': 'chat_event', 'chat_event': body}); diff --git a/app/test/features/chat/domain/chat_commands_test.dart b/app/test/features/chat/domain/chat_commands_test.dart index ff46fe6b..7b5b8951 100644 --- a/app/test/features/chat/domain/chat_commands_test.dart +++ b/app/test/features/chat/domain/chat_commands_test.dart @@ -8,6 +8,7 @@ void main() { 'close', 'rename', 'stop', + 'stop_tasks', 'help', ]); expect(chatCommands.map((command) => command.usage), [ @@ -15,6 +16,7 @@ void main() { '/close', '/rename <title>', '/stop', + '/stop_tasks', '/help', ]); expect(chatCommands.map((command) => command.summary), [ @@ -22,6 +24,7 @@ void main() { 'Finish this session for every client, keeping its history', 'Rename this session', 'Stop the turn that is running', + 'Stop all background tasks in this chat', 'List every command', ]); expect( diff --git a/internal/claude/chat.go b/internal/claude/chat.go index cf448833..75c838d1 100644 --- a/internal/claude/chat.go +++ b/internal/claude/chat.go @@ -426,6 +426,44 @@ func (c *Chat) Interrupt(ctx context.Context, id string) error { return err } +// StopTasks uses Claude Code's separate stop_task control request. It does not +// send interrupt, so the foreground turn and its queued prompts remain alive. +func (c *Chat) StopTasks(ctx context.Context, id string) (int, error) { + s := c.session(id) + if s == nil { + return 0, nil + } + s.awaitReady(ctx) + s.mu.Lock() + proc := s.proc + var tasks []string + for toolID, snapshot := range s.shells { + if !snapshot.background || snapshot.shell.Status != protocol.ChatShellRunning { + continue + } + taskID := snapshot.taskID + if taskID == "" { + taskID = toolID + } + tasks = append(tasks, taskID) + } + s.mu.Unlock() + if proc == nil { + return 0, nil + } + stopped := 0 + for _, taskID := range tasks { + requestCtx, cancel := context.WithTimeout(ctx, controlRequestTimeout) + _, err := proc.request(requestCtx, "stop_task", map[string]any{"task_id": taskID}) + cancel() + if err != nil { + return stopped, err + } + stopped++ + } + return stopped, nil +} + // ActivateSkill has no out-of-band equivalent in Claude Code; skills resolve // through the CLI's own /skill mechanism. func (c *Chat) ActivateSkill(context.Context, string, string) error { diff --git a/internal/claude/claude_test.go b/internal/claude/claude_test.go index c0b4e672..bfecade7 100644 --- a/internal/claude/claude_test.go +++ b/internal/claude/claude_test.go @@ -257,6 +257,57 @@ func TestInterruptSettlesTheTurn(t *testing.T) { } } +func TestInterruptLeavesBackgroundTaskAndStopTasksEndsIt(t *testing.T) { + chat := testChat(t) + session := newCreatedChat(t, chat) + if err := chat.Prompt(context.Background(), session.ID, "background task"); err != nil { + t.Fatal(err) + } + eventually(t, "background shell", func() bool { + shells, err := chat.Shells(context.Background(), session.ID) + return err == nil && len(shells) == 1 && shells[0].Status == protocol.ChatShellRunning + }) + + // The fake turn has already yielded its result, so mark the session running + // to exercise the same control path used by an active foreground turn. + s := chat.session(session.ID) + s.mu.Lock() + s.running = true + s.mu.Unlock() + if err := chat.Interrupt(context.Background(), session.ID); err != nil { + t.Fatalf("interrupt: %v", err) + } + if shells, err := chat.Shells(context.Background(), session.ID); err != nil || len(shells) != 1 || shells[0].Status != protocol.ChatShellRunning { + t.Fatalf("interrupt ended background task: shells=%+v err=%v", shells, err) + } + + // A foreground tool may still be running while the operator stops + // background work. It must not be included in the stop_task requests. + s.mu.Lock() + s.shells["toolu_foreground"] = &shellSnapshot{ + shell: protocol.ChatShell{ + ID: "toolu_foreground", + Status: protocol.ChatShellRunning, + Command: "foreground command", + }, + } + s.mu.Unlock() + stopped, err := chat.StopTasks(context.Background(), session.ID) + if err != nil { + t.Fatalf("stop tasks: %v", err) + } + if stopped != 1 { + t.Fatalf("stopped tasks = %d, want only the background task", stopped) + } + eventually(t, "stopped shell", func() bool { + shells, err := chat.Shells(context.Background(), session.ID) + if err != nil || len(shells) != 1 { + return false + } + return shells[0].ID == "toolu_foreground" && shells[0].Status == protocol.ChatShellRunning + }) +} + func TestModelChoiceIsAppliedAndProcessResumes(t *testing.T) { chat := testChat(t) session := newCreatedChat(t, chat) diff --git a/internal/claude/testdata/fake-claude.py b/internal/claude/testdata/fake-claude.py index f70423cc..c0006714 100644 --- a/internal/claude/testdata/fake-claude.py +++ b/internal/claude/testdata/fake-claude.py @@ -243,6 +243,11 @@ def handle(line): state["pending"] = None send({"type": "result", "subtype": "error_during_execution", "is_error": True, "result": "Interrupted", "session_id": state["session"]}) + elif subtype == "stop_task": + respond(value.get("request_id"), {}) + send({"type": "system", "subtype": "task_notification", + "task_id": request.get("task_id"), "tool_use_id": "toolu_bg_fake", + "status": "stopped", "summary": "Background task stopped"}) elif subtype == "get_usage": respond(value.get("request_id"), {"session": { "total_cost_usd": 0.25, diff --git a/internal/codex/chat.go b/internal/codex/chat.go index a3216a15..9e3cf060 100644 --- a/internal/codex/chat.go +++ b/internal/codex/chat.go @@ -550,6 +550,10 @@ func (c *Chat) Interrupt(ctx context.Context, id string) error { return err } +func (c *Chat) StopTasks(context.Context, string) (int, error) { + return 0, errors.New("Codex does not expose a separate background-task stop operation") +} + // ReleaseSession stops an active Codex turn while preserving the thread and // its transcript. Codex has no separate per-thread process to reap. func (c *Chat) ReleaseSession(ctx context.Context, id string) error { diff --git a/internal/opencode/chat.go b/internal/opencode/chat.go index 6373d8d5..0288a36d 100644 --- a/internal/opencode/chat.go +++ b/internal/opencode/chat.go @@ -322,6 +322,26 @@ func (c *Chat) Interrupt(ctx context.Context, id string) error { return nil } +// StopTasks terminates background shell operations, without interrupting the +// session's foreground turn. +func (c *Chat) StopTasks(ctx context.Context, id string) (int, error) { + shells, err := c.Shells(ctx, id) + if err != nil { + return 0, err + } + stopped := 0 + for _, shell := range shells { + if shell.Status != protocol.ChatShellRunning { + continue + } + if _, err := c.call(ctx, "delete", "/api/shell/"+url.PathEscape(shell.ID), nil); err != nil { + return stopped, fmt.Errorf("stop shell %s: %w", shell.ID, err) + } + stopped++ + } + return stopped, nil +} + // ReleaseSession stops active and background work for an explicit operator // close or /new without deleting the persisted native conversation. OpenCode // interrupt only stops the foreground drain; running shells are separate native diff --git a/internal/opencode/chat_test.go b/internal/opencode/chat_test.go index 29effe32..c064a887 100644 --- a/internal/opencode/chat_test.go +++ b/internal/opencode/chat_test.go @@ -410,6 +410,42 @@ func TestChatReleaseSessionStopsRunningShells(t *testing.T) { } } +func TestChatStopTasksDeletesOnlyRunningShells(t *testing.T) { + var requests []string + var mu sync.Mutex + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + requests = append(requests, r.Method+" "+r.URL.Path) + mu.Unlock() + w.Header().Set("Content-Type", "application/json") + switch r.URL.Path { + case "/api/shell": + _, _ = w.Write([]byte(`{"data":[{"id":"sh_running","status":"running","metadata":{"sessionID":"ses_1"}},{"id":"sh_done","status":"exited","metadata":{"sessionID":"ses_1"}}]}`)) + case "/api/shell/sh_running": + _, _ = w.Write([]byte(`{}`)) + default: + w.WriteHeader(http.StatusNotFound) + } + })) + defer srv.Close() + + chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) + stopped, err := chat.StopTasks(context.Background(), "ses_1") + if err != nil { + t.Fatal(err) + } + if stopped != 1 { + t.Fatalf("stopped = %d, want 1", stopped) + } + mu.Lock() + got := append([]string(nil), requests...) + mu.Unlock() + want := []string{"GET /api/shell", "DELETE /api/shell/sh_running"} + if !slices.Equal(got, want) { + t.Fatalf("stop requests = %v, want %v", got, want) + } +} + // TestDecodeChatMessages loads a seeded user + assistant session in both // response envelopes the two surfaces return and asserts the turns come back // with role, id, part order, part ids and the completed tool's input, content diff --git a/internal/protocol/chat.go b/internal/protocol/chat.go index 9bc30673..537a6fd9 100644 --- a/internal/protocol/chat.go +++ b/internal/protocol/chat.go @@ -28,6 +28,9 @@ const ( ChatPrompt = "chat_prompt" ChatMessages = "chat_messages" ChatInterrupt = "chat_interrupt" + // ChatStopTasks stops background tasks without interrupting the current turn. + // Older clients ignore this additive command. + ChatStopTasks = "chat_stop_tasks" ChatReply = "chat_reply" // ChatClose finishes an operator session and records it as closed on the // server: any in-flight turn is interrupted through the existing interrupt, @@ -149,6 +152,13 @@ const ( ChatPermission = "chat_permission" ) +// ChatStopTasksResult reports the result of an explicit background-task stop. +type ChatStopTasksResult struct { + SessionID string `json:"session_id"` + Stopped int `json:"stopped"` + Message string `json:"message,omitempty"` +} + const ( ChatAutomationSupported = "supported" ChatAutomationUnavailable = "unavailable" diff --git a/internal/protocol/message.go b/internal/protocol/message.go index 3de91cf7..da72037c 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -262,8 +262,9 @@ type Message struct { // body names the session like ChatQuery. A chat_prompt response sets // ChatQueued when the prompt had to wait for an in-flight turn and was // accepted into the session's queue instead of being sent immediately. - ChatSubscribe *ChatQuery `json:"chat_subscribe,omitempty"` - ChatQueued bool `json:"chat_queued,omitempty"` + ChatSubscribe *ChatQuery `json:"chat_subscribe,omitempty"` + ChatQueued bool `json:"chat_queued,omitempty"` + ChatStopTasks *ChatStopTasksResult `json:"chat_stop_tasks,omitempty"` // ChatSteered means the prompt was handed to the turn already running; its // reply is that turn's continuing output. ChatSteered bool `json:"chat_steered,omitempty"` diff --git a/internal/server/chat.go b/internal/server/chat.go index 6ae310b0..ac4ce616 100644 --- a/internal/server/chat.go +++ b/internal/server/chat.go @@ -49,6 +49,10 @@ type chatPromptWithMessageID interface { PromptWithMessageID(context.Context, string, string, string) error } +type chatTaskStopper interface { + StopTasks(context.Context, string) (int, error) +} + // chatPromptWithFiles is implemented by a broker that can hand local files to // the agent with a prompt. The server writes browser attachment bytes to private // temporary files first; a browser URI is not readable by the agent service. @@ -195,6 +199,9 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker case protocol.ChatInterrupt: handleChatSimple(ctx, request, broker, hub, write) return true + case protocol.ChatStopTasks: + handleChatStopTasks(ctx, request, broker, write) + return true case protocol.ChatReply: handleChatSimple(ctx, request, broker, hub, write) return true diff --git a/internal/server/chat_manager.go b/internal/server/chat_manager.go index 6e0b1605..d322f491 100644 --- a/internal/server/chat_manager.go +++ b/internal/server/chat_manager.go @@ -746,6 +746,18 @@ func (m *chatManager) Shells(ctx context.Context, sessionID string) ([]protocol. return nil, nil } +func (m *chatManager) StopTasks(ctx context.Context, sessionID string) (int, error) { + adapter, err := m.brokerFor(ctx, sessionID) + if err != nil { + return 0, err + } + stopper, ok := adapter.(chatTaskStopper) + if !ok { + return 0, errors.New("this chat backend cannot stop background tasks separately") + } + return stopper.StopTasks(ctx, sessionID) +} + func (m *chatManager) Reply(ctx context.Context, request protocol.ChatReplyRequest) error { adapter, err := m.brokerFor(ctx, request.SessionID) if err != nil { diff --git a/internal/server/chat_stop_tasks.go b/internal/server/chat_stop_tasks.go new file mode 100644 index 00000000..ff072da1 --- /dev/null +++ b/internal/server/chat_stop_tasks.go @@ -0,0 +1,39 @@ +package server + +import ( + "context" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +func handleChatStopTasks(ctx context.Context, request protocol.Message, broker chatBroker, write func(protocol.Message) error) { + query := request.ChatQuery + if query == nil || !validChatSessionID(query.SessionID) { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid chat session id is required"}) + return + } + if broker == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) + return + } + stopper, ok := broker.(chatTaskStopper) + if !ok { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "this chat backend cannot stop background tasks separately"}) + return + } + stopped, err := stopper.StopTasks(ctx, query.SessionID) + if err != nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) + return + } + message := "No background tasks are running in this chat." + if stopped > 0 { + message = "Stopped background tasks." + } + _ = write(protocol.Message{ + Type: protocol.ChatStopTasks, ID: request.ID, + ChatStopTasks: &protocol.ChatStopTasksResult{ + SessionID: query.SessionID, Stopped: stopped, Message: message, + }, + }) +} diff --git a/internal/server/chat_test.go b/internal/server/chat_test.go index daa97af0..5b6513c4 100644 --- a/internal/server/chat_test.go +++ b/internal/server/chat_test.go @@ -211,6 +211,16 @@ func (f *fakeChat) Interrupt(context.Context, string) error { return f.interruptErr } +type fakeTaskStopChat struct { + *fakeChat + stopped int +} + +func (f *fakeTaskStopChat) StopTasks(context.Context, string) (int, error) { + f.stopped++ + return f.stopped, nil +} + func (f *fakeChat) ReleaseSession(_ context.Context, sessionID string) error { f.mu.Lock() defer f.mu.Unlock() @@ -850,6 +860,27 @@ func TestChatInterruptAndReply(t *testing.T) { } } +func TestChatStopTasksRepliesWithStoppedCount(t *testing.T) { + broker := &fakeTaskStopChat{fakeChat: scriptedChat()} + ctx, _, conn := dialChat(t, broker) + if err := wsjson.Write(ctx, conn, protocol.Message{ + Type: protocol.ChatStopTasks, ID: "st1", + ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}, + }); err != nil { + t.Fatal(err) + } + var response protocol.Message + if err := readTestFrame(ctx, conn, &response); err != nil { + t.Fatal(err) + } + if response.Type != protocol.ChatStopTasks || response.ID != "st1" || response.ChatStopTasks == nil { + t.Fatalf("stop tasks response = %+v", response) + } + if response.ChatStopTasks.Stopped != 1 || response.ChatStopTasks.Message != "Stopped background tasks." { + t.Fatalf("stop tasks result = %+v", response.ChatStopTasks) + } +} + // TestChatInterruptEndsRunningPrompt is the task evidence: it starts a // long-running turn through the real opencode.Chat adapter over an httptest SSE // fixture, sends chat_interrupt, and asserts the run ends. The fixture records From 83e6553da4f2f4f7aa67d5ed2bce680501e3bd7b Mon Sep 17 00:00:00 2001 From: Alan Silva <alanfortlink@gmail.com> Date: Fri, 13 Nov 2026 18:00:57 +0000 Subject: [PATCH 2/2] Expect /stop_tasks among the /s command suggestions --- app/test/features/chat/domain/chat_commands_test.dart | 1 + 1 file changed, 1 insertion(+) diff --git a/app/test/features/chat/domain/chat_commands_test.dart b/app/test/features/chat/domain/chat_commands_test.dart index 7b5b8951..e1d11d30 100644 --- a/app/test/features/chat/domain/chat_commands_test.dart +++ b/app/test/features/chat/domain/chat_commands_test.dart @@ -50,6 +50,7 @@ void main() { ]); expect(chatCommandSuggestions('/s').map((command) => command.name), [ 'stop', + 'stop_tasks', ]); });