feat(tui): add argument auto-completion for /toolset-restart

Pressing Tab after "/toolset-restart " opens a completion popup listing the
current agent's toolsets. Non-restartable toolsets are shown but dimmed and
annotated "(not restartable)", and cannot be selected. The completion opens
only on Tab, never auto-opening on space.

The argument-completion hook (ArgumentCandidate/CompleteArgument on
commands.Item plus the ArgumentCompleter source interface) is command-agnostic
so it can be reused for other commands (e.g. /effort, /drop) later, though only
/toolset-restart is wired up here.

Author: aheritier

pkg/runtime/runtime.go

@@ -1139,6 +1139,7 @@ func toolsetStatusFor(ts tools.ToolSet) tools.ToolsetStatus {
 		// earlier if Start failed.
 		status.State = lifecycleStateForUnsupervised(ts)
 	}
+	_, status.Restartable = tools.As[tools.Restartable](ts)
 	status.Name = nameFor(ts, status.Description)
 	return status
 }

pkg/runtime/toolsetstatus_test.go

@@ -59,6 +59,23 @@ func TestToolsetStatusFor_NoStatableMeansReady(t *testing.T) {
 	assert.Equal(t, 0, got.RestartCount)
 	require.NoError(t, got.LastError)
 	assert.Equal(t, "filesystem", got.Description)
+	assert.False(t, got.Restartable, "toolset without Restart() must report Restartable=false")
+}
+
+func TestToolsetStatusFor_RestartableReportsTrue(t *testing.T) {
+	t.Parallel()
+
+	ts := &restartableToolset{desc: "mcp(stdio cmd=foo)", state: lifecycle.StateInfo{State: lifecycle.StateReady}}
+	got := toolsetStatusFor(ts)
+	assert.True(t, got.Restartable)
+}
+
+func TestToolsetStatusFor_NonRestartableReportsFalse(t *testing.T) {
+	t.Parallel()
+
+	ts := &statefulToolset{desc: "filesystem", info: lifecycle.StateInfo{State: lifecycle.StateReady}}
+	got := toolsetStatusFor(ts)
+	assert.False(t, got.Restartable)
 }
 
 // TestToolsetStatusFor_UnwrapsStartable verifies the inner Statable is

pkg/tools/status.go

@@ -43,4 +43,9 @@ type ToolsetStatus struct {
 	// RestartCount is the number of supervisor restarts since the last
 	// successful Ready transition. Zero for toolsets without a supervisor.
 	RestartCount int
+	// Restartable reports whether the toolset implements Restartable
+	// (typically supervisor-backed MCP/LSP toolsets). Surfaces such as the
+	// /toolset-restart completion popup use this to annotate, not hide,
+	// entries that cannot actually be restarted.
+	Restartable bool
 }

pkg/tui/commands/commands.go

@@ -1,6 +1,7 @@
 package commands
 
 import (
+	"cmp"
 	"context"
 	"fmt"
 	"slices"
@@ -11,6 +12,7 @@ import (
 	"github.com/docker/docker-agent/pkg/app"
 	"github.com/docker/docker-agent/pkg/config/types"
 	"github.com/docker/docker-agent/pkg/feedback"
+	"github.com/docker/docker-agent/pkg/tools"
 	mcptools "github.com/docker/docker-agent/pkg/tools/mcp"
 	"github.com/docker/docker-agent/pkg/tui/components/toolcommon"
 	"github.com/docker/docker-agent/pkg/tui/core"
@@ -26,6 +28,18 @@ type Category struct {
 	Commands []Item
 }
 
+// ArgumentCandidate is one completable value for a command's argument,
+// e.g. a toolset name for /toolset-restart. It is intentionally free of any
+// completion-UI or app-domain types so pkg/tui/commands stays decoupled from
+// both pkg/tui/components/completion and pkg/app.
+type ArgumentCandidate struct {
+	Label       string
+	Description string
+	// Disabled marks a candidate that is shown for context but cannot be
+	// submitted (e.g. a non-restartable toolset for /toolset-restart).
+	Disabled bool
+}
+
 // Item represents a single command in the palette
 type Item struct {
 	ID           string
@@ -38,6 +52,11 @@ type Item struct {
 	// Immediate marks commands that should run as soon as they are submitted
 	// instead of being treated as ordinary queued chat input.
 	Immediate bool
+	// CompleteArgument, when set, returns the candidates for this command's
+	// argument. Called lazily at completion-popup-open time so results
+	// reflect current runtime state (e.g. toolset lifecycle). Nil for
+	// commands with no argument completion.
+	CompleteArgument func() []ArgumentCandidate
 }
 
 func builtInSessionCommands() []Item {
@@ -577,13 +596,72 @@ func newMCPPromptItem(promptName string, promptInfo mcptools.PromptInfo) Item {
 	}
 }
 
+// toolsetStatusSource is the minimal surface toolsetRestartCandidates needs.
+// *app.App satisfies it; tests can supply a stub instead of constructing a
+// full application.
+type toolsetStatusSource interface {
+	CurrentAgentToolsetStatuses() []tools.ToolsetStatus
+}
+
+// toolsetRestartCandidates returns one ArgumentCandidate per toolset of the
+// current agent, in declaration order, deduplicated by name (preferring the
+// restartable entry when duplicate names disagree — display names are not
+// guaranteed unique, mirroring runtime.RestartToolset's own matching).
+// Non-restartable toolsets are marked Disabled rather than omitted, so the
+// popup teaches users the full toolset inventory and why a restart isn't
+// offered for some of them.
+func toolsetRestartCandidates(source toolsetStatusSource) []ArgumentCandidate {
+	statuses := source.CurrentAgentToolsetStatuses()
+	byName := make(map[string]tools.ToolsetStatus, len(statuses))
+	order := make([]string, 0, len(statuses))
+	for _, s := range statuses {
+		if s.Name == "" {
+			continue
+		}
+		if existing, ok := byName[s.Name]; !ok {
+			byName[s.Name] = s
+			order = append(order, s.Name)
+		} else if !existing.Restartable && s.Restartable {
+			byName[s.Name] = s
+		}
+	}
+
+	candidates := make([]ArgumentCandidate, 0, len(order))
+	for _, name := range order {
+		s := byName[name]
+		candidates = append(candidates, ArgumentCandidate{
+			Label:       s.Name,
+			Description: cmp.Or(s.Kind, "Built-in") + " · " + s.State.String(),
+			Disabled:    !s.Restartable,
+		})
+	}
+	return candidates
+}
+
+// attachToolsetRestartCompletion wires the toolset-name argument completer
+// onto the /toolset-restart item. Attached post-hoc (rather than inline in
+// builtInSessionCommands) so that function stays free of any status-source
+// dependency.
+func attachToolsetRestartCompletion(items []Item, source toolsetStatusSource) {
+	for i := range items {
+		if items[i].ID != "session.toolset.restart" {
+			continue
+		}
+		items[i].CompleteArgument = func() []ArgumentCandidate {
+			return toolsetRestartCandidates(source)
+		}
+		return
+	}
+}
+
 // BuildCommandCategories builds the list of command categories for the command palette
 func BuildCommandCategories(ctx context.Context, application *app.App) []Category {
 	// Get session commands and filter based on model capabilities
 	sessionCommands := builtInSessionCommands()
 	if !application.SnapshotsEnabled() {
 		sessionCommands = removeByIDs(sessionCommands, snapshotCommandIDs)
 	}
+	attachToolsetRestartCompletion(sessionCommands, application)
 
 	categories := []Category{
 		{

pkg/tui/commands/commands_test.go

@@ -6,6 +6,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/docker/docker-agent/pkg/tools"
+	"github.com/docker/docker-agent/pkg/tools/lifecycle"
 	"github.com/docker/docker-agent/pkg/tui/messages"
 )
 
@@ -258,3 +260,81 @@ func TestRemoveByIDsDropsSnapshotCommands(t *testing.T) {
 	assert.Nil(t, parser.Parse("/snapshots"))
 	require.NotNil(t, parser.Parse("/exit"))
 }
+
+// stubToolsetStatusSource is a minimal toolsetStatusSource for exercising
+// toolsetRestartCandidates without a real *app.App.
+type stubToolsetStatusSource struct {
+	statuses []tools.ToolsetStatus
+}
+
+func (s stubToolsetStatusSource) CurrentAgentToolsetStatuses() []tools.ToolsetStatus {
+	return s.statuses
+}
+
+func TestToolsetRestartCandidates_AllShownWithDisabledFlag(t *testing.T) {
+	t.Parallel()
+
+	source := stubToolsetStatusSource{statuses: []tools.ToolsetStatus{
+		{Name: "github", Kind: "MCP", State: lifecycle.StateReady, Restartable: true},
+		{Name: "filesystem", State: lifecycle.StateReady, Restartable: false},
+	}}
+
+	candidates := toolsetRestartCandidates(source)
+	require.Len(t, candidates, 2)
+
+	assert.Equal(t, "github", candidates[0].Label)
+	assert.False(t, candidates[0].Disabled)
+	assert.Contains(t, candidates[0].Description, "MCP")
+
+	assert.Equal(t, "filesystem", candidates[1].Label)
+	assert.True(t, candidates[1].Disabled, "non-restartable toolsets must be shown, not hidden")
+	assert.Contains(t, candidates[1].Description, "Built-in")
+}
+
+func TestToolsetRestartCandidates_DedupePrefersRestartable(t *testing.T) {
+	t.Parallel()
+
+	source := stubToolsetStatusSource{statuses: []tools.ToolsetStatus{
+		{Name: "dup", State: lifecycle.StateStopped, Restartable: false},
+		{Name: "dup", State: lifecycle.StateReady, Restartable: true},
+	}}
+
+	candidates := toolsetRestartCandidates(source)
+	require.Len(t, candidates, 1, "duplicate names must be deduplicated")
+	assert.False(t, candidates[0].Disabled, "the restartable entry must win over the non-restartable duplicate")
+}
+
+func TestToolsetRestartCandidates_EmptyNameSkipped(t *testing.T) {
+	t.Parallel()
+
+	source := stubToolsetStatusSource{statuses: []tools.ToolsetStatus{{Name: "", Restartable: true}}}
+	assert.Empty(t, toolsetRestartCandidates(source))
+}
+
+func TestAttachToolsetRestartCompletion(t *testing.T) {
+	t.Parallel()
+
+	items := builtInSessionCommands()
+	source := stubToolsetStatusSource{statuses: []tools.ToolsetStatus{
+		{Name: "github", Restartable: true},
+	}}
+	attachToolsetRestartCompletion(items, source)
+
+	var restart, other *Item
+	for i := range items {
+		switch items[i].ID {
+		case "session.toolset.restart":
+			restart = &items[i]
+		case "session.exit":
+			other = &items[i]
+		}
+	}
+	require.NotNil(t, restart)
+	require.NotNil(t, restart.CompleteArgument, "the restart item must get a completer")
+	candidates := restart.CompleteArgument()
+	require.Len(t, candidates, 1)
+	assert.Equal(t, "github", candidates[0].Label)
+
+	require.NotNil(t, other)
+	assert.Nil(t, other.CompleteArgument, "commands without a provider keep a nil CompleteArgument")
+}

pkg/tui/components/completion/completion.go

@@ -34,6 +34,11 @@ type Item struct {
 	Value       string
 	Execute     func() tea.Cmd
 	Pinned      bool // Pinned items always appear at the top, in original order
+	// Disabled marks an item that is shown for context but cannot be
+	// submitted (e.g. a non-restartable toolset for /toolset-restart).
+	// Enter/Tab are a no-op on it and it never drives the ghost-suggestion
+	// preview; cursor movement over it is still allowed.
+	Disabled bool
 }
 
 type OpenMsg struct {
@@ -262,11 +267,17 @@ func (c *manager) Update(msg tea.Msg) (layout.Model, tea.Cmd) {
 			return c, cmd
 
 		case key.Matches(msg, c.keyMap.Enter):
-			c.visible = false
 			if len(c.filteredItems) == 0 || c.selected >= len(c.filteredItems) {
+				c.visible = false
 				return c, core.CmdHandler(ClosedMsg{})
 			}
 			selectedItem := c.filteredItems[c.selected]
+			if selectedItem.Disabled {
+				// No-op: the dimmed style already signals why this entry
+				// can't be submitted. Keep the popup open.
+				return c, nil
+			}
+			c.visible = false
 			return c, tea.Sequence(
 				core.CmdHandler(SelectedMsg{
 					Value:      selectedItem.Value,
@@ -276,11 +287,15 @@ func (c *manager) Update(msg tea.Msg) (layout.Model, tea.Cmd) {
 				core.CmdHandler(ClosedMsg{}),
 			)
 		case key.Matches(msg, c.keyMap.Tab):
-			c.visible = false
 			if len(c.filteredItems) == 0 || c.selected >= len(c.filteredItems) {
+				c.visible = false
 				return c, core.CmdHandler(ClosedMsg{})
 			}
 			selectedItem := c.filteredItems[c.selected]
+			if selectedItem.Disabled {
+				return c, nil
+			}
+			c.visible = false
 			return c, tea.Sequence(
 				core.CmdHandler(SelectedMsg{
 					Value:      selectedItem.Value,
@@ -339,7 +354,14 @@ func (c *manager) View() string {
 
 			itemStyle := styles.CompletionNormalStyle
 			descStyle := styles.CompletionDescStyle
-			if isSelected {
+			switch {
+			case item.Disabled && isSelected:
+				itemStyle = styles.CompletionDisabledSelectedStyle
+				descStyle = styles.CompletionDisabledDescStyle
+			case item.Disabled:
+				itemStyle = styles.CompletionDisabledStyle
+				descStyle = styles.CompletionDisabledDescStyle
+			case isSelected:
 				itemStyle = styles.CompletionSelectedStyle
 				descStyle = styles.CompletionSelectedDescStyle
 			}
@@ -376,12 +398,18 @@ func (c *manager) GetLayers() []*lipgloss.Layer {
 	}
 }
 
-// notifySelectionChanged sends a SelectionChangedMsg with the currently selected item's value
+// notifySelectionChanged sends a SelectionChangedMsg with the currently selected item's value.
+// Disabled items report an empty value so the editor's ghost-suggestion
+// preview shows nothing for entries that can't be submitted.
 func (c *manager) notifySelectionChanged() tea.Cmd {
 	if len(c.filteredItems) == 0 || c.selected >= len(c.filteredItems) {
 		return core.CmdHandler(SelectionChangedMsg{Value: ""})
 	}
-	return core.CmdHandler(SelectionChangedMsg{Value: c.filteredItems[c.selected].Value})
+	selectedItem := c.filteredItems[c.selected]
+	if selectedItem.Disabled {
+		return core.CmdHandler(SelectionChangedMsg{Value: ""})
+	}
+	return core.CmdHandler(SelectionChangedMsg{Value: selectedItem.Value})
 }
 
 func (c *manager) filterItems(query string) {