feat: /btw mid-query input, plan mode enforcement, plugin management - v0.5.0

/btw & message queuing:
- Users can now type during query execution (input visible while thinking)
- Enter queues a message that auto-sends when current query completes
- /btw <question> queues a side question
- Queued message count shown in UI: "(2 queued)"
- Multiple queued messages combined and sent as follow-up

Plan mode enforcement:
- /plan now actually blocks write tools (Edit, Write, Bash) via permission callback
- Read-only tools (Read, Glob, Grep, WebFetch) still allowed in plan mode
- Clear error message: "Plan mode: write operations blocked"

Plugin management:
- /plugin list - list all plugins
- /plugin reload - reload plugins from disk
- /plugin create <name> - scaffold new plugin with plugin.json

50 slash commands, 6000+ lines Go

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: idoubi

internal/slash/commands.go

@@ -499,8 +499,33 @@ func (h *Handler) testCmd(args []string) Result {
 // ─── /plugin ──────────────────────────────────────
 
 func (h *Handler) pluginCmd(args []string) Result {
-	allPlugins := plugins.LoadAll(config.GlobalConfigDir())
-	return Result{Message: plugins.FormatPluginList(allPlugins)}
+	configDir := config.GlobalConfigDir()
+
+	if len(args) == 0 {
+		allPlugins := plugins.LoadAll(configDir)
+		return Result{Message: plugins.FormatPluginList(allPlugins)}
+	}
+
+	switch args[0] {
+	case "list":
+		allPlugins := plugins.LoadAll(configDir)
+		return Result{Message: plugins.FormatPluginList(allPlugins)}
+	case "reload":
+		allPlugins := plugins.LoadAll(configDir)
+		return Result{Message: fmt.Sprintf("✓ Reloaded %d plugins", len(allPlugins))}
+	case "create":
+		if len(args) < 2 {
+			return Result{Message: "Usage: /plugin create <name>"}
+		}
+		name := args[1]
+		dir := filepath.Join(configDir, "plugins", name)
+		os.MkdirAll(dir, 0755)
+		manifest := fmt.Sprintf(`{"name": "%s", "description": "", "version": "0.1.0"}`, name)
+		os.WriteFile(filepath.Join(dir, "plugin.json"), []byte(manifest), 0644)
+		return Result{Message: fmt.Sprintf("✓ Plugin %q created at %s\n\nAdd skills in %s/skills/<name>/SKILL.md", name, dir, dir)}
+	default:
+		return Result{Message: "Usage: /plugin [list|reload|create <name>]"}
+	}
 }
 
 // ─── /hooks ───────────────────────────────────────
@@ -1254,6 +1279,18 @@ func (h *Handler) worktreeCmd(args []string) Result {
 	}
 }
 
+// ─── /btw ─────────────────────────────────────────
+
+func (h *Handler) btwCmd(args []string) Result {
+	if len(args) == 0 {
+		return Result{Message: "Usage: /btw <question>\n\nAsk a quick side question. If the agent is busy, it will be queued and answered next."}
+	}
+	question := strings.Join(args, " ")
+	return Result{
+		SkillPrompt: fmt.Sprintf("[Side question from user — answer briefly then continue previous task]: %s", question),
+	}
+}
+
 // ─── helpers ──────────────────────────────────────
 
 func min(a, b int) int {

internal/slash/slash.go

@@ -110,6 +110,8 @@ func AllCommands() []CommandDef {
 		// Multi-agent
 		{Name: "/team", Description: "Team management (create, add, send, inbox)", HasArgs: true},
 		{Name: "/worktree", Description: "Git worktree isolation (enter, exit)", HasArgs: true},
+		// Mid-query
+		{Name: "/btw", Description: "Side question (queued during execution)", HasArgs: true},
 	}
 }
 
@@ -257,6 +259,8 @@ func (h *Handler) Handle(input string) Result {
 		return h.teamCmd(args)
 	case "/worktree":
 		return h.worktreeCmd(args)
+	case "/btw":
+		return h.btwCmd(args)
 	default:
 		// Try skill invocation
 		if result, ok := h.HandleSkillInvocation(cmd, args); ok {

internal/tui/model.go

@@ -127,6 +127,9 @@ type Model struct {
 	transcriptMode bool
 	planMode       bool   // no-execution mode
 	spinnerVerb    string // current fun spinner verb
+
+	// Queued messages (typed during query execution)
+	queuedMessages []string
 }
 
 // DisplayBlock represents one visual block in the conversation
@@ -264,9 +267,15 @@ func (m *Model) createPermissionCallback() types.CanUseToolFn {
 			}
 		}
 
-		// plan mode: allow all tools (planning can read/analyze)
-		if mode == types.PermissionModePlan {
-			return allow, nil
+		// plan mode: only allow read-only tools, block writes
+		if mode == types.PermissionModePlan || m.planMode {
+			if tool.IsReadOnly(input) {
+				return allow, nil
+			}
+			return &types.PermissionDecision{
+				Behavior: types.PermissionDeny,
+				Reason:   "Plan mode: write operations blocked. Exit plan mode with /plan to execute.",
+			}, nil
 		}
 
 		// default mode: auto-approve read-only tools, ask for write tools
@@ -402,6 +411,13 @@ func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.input.Focus()
 		// Ring terminal bell to notify user
 		fmt.Print("\a")
+
+		// Process queued messages (typed during query via /btw or Enter)
+		if len(m.queuedMessages) > 0 {
+			combined := strings.Join(m.queuedMessages, "\n\nAlso: ")
+			m.queuedMessages = nil
+			return m, m.sendQuery(combined)
+		}
 		return m, nil
 
 	case permissionRequestMsg:
@@ -468,8 +484,8 @@ func (m *Model) handleKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	case statePermission:
 		return m.handlePermissionKey(msg)
 	case stateQuerying:
-		// Allow scrolling while querying
-		return m.handleScrollKey(msg)
+		// Allow scrolling and typing during query
+		return m.handleQueryingKey(msg)
 	}
 
 	return m, nil
@@ -509,6 +525,50 @@ func (m *Model) handleScrollKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	return m, nil
 }
 
+func (m *Model) handleQueryingKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	// Scroll keys
+	switch msg.String() {
+	case "up", "k":
+		m.viewport.LineUp(1)
+		m.userScrolled = true
+		return m, nil
+	case "down", "j":
+		m.viewport.LineDown(1)
+		if m.viewport.AtBottom() {
+			m.userScrolled = false
+		}
+		return m, nil
+	case "pgup", "ctrl+b":
+		m.viewport.HalfViewUp()
+		m.userScrolled = true
+		return m, nil
+	case "pgdown", "ctrl+f":
+		m.viewport.HalfViewDown()
+		if m.viewport.AtBottom() {
+			m.userScrolled = false
+		}
+		return m, nil
+	case "enter":
+		// Queue a message typed during query (btw-style)
+		text := m.input.Value()
+		if text != "" {
+			m.input.Reset()
+			m.queuedMessages = append(m.queuedMessages, text)
+			m.blocks = append(m.blocks, DisplayBlock{
+				Type:      "system",
+				Content:   fmt.Sprintf("📝 Queued: %s", text),
+				Timestamp: time.Now(),
+			})
+			m.refreshViewport()
+		}
+		return m, nil
+	}
+
+	// Let textarea handle regular typing (so user can compose during query)
+	_, cmd := m.input.Update(msg)
+	return m, cmd
+}
+
 func (m *Model) handleInputKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	// Scrolling keys work even in input mode
 	switch msg.String() {
@@ -835,6 +895,12 @@ func (m *Model) View() string {
 		b.WriteString(m.renderPermissionPrompt())
 	case stateQuerying:
 		b.WriteString(m.renderActivityLine())
+		b.WriteString("\n")
+		// Show input so user can type /btw or queue messages during query
+		b.WriteString(m.input.View())
+		if len(m.queuedMessages) > 0 {
+			b.WriteString(theme.DimText.Render(fmt.Sprintf("  (%d queued)", len(m.queuedMessages))))
+		}
 	case stateInit:
 		b.WriteString(fmt.Sprintf("  %s Initializing...", m.spinner.View()))
 	default: