test: Add comprehensive tests for PRs dlorenc#334, dlorenc#335, dlorenc#336, dlorenc#340, dlorenc#342

Add 659 lines of tests covering:
- All 18 structured error constructors from PR dlorenc#340 (individual + bulk format test)
- JSON CLI output edge cases from PR dlorenc#335 (empty/nested/all-internal subcommands)
- Structured CLIError validation for workspace names from PR dlorenc#340 integration
- Message routing edge cases from PR dlorenc#342 (no acked, mixed ack status)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: whitmo

internal/cli/cli_test.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/dlorenc/multiclaude/internal/daemon"
+	"github.com/dlorenc/multiclaude/internal/errors"
 	"github.com/dlorenc/multiclaude/internal/messages"
 	"github.com/dlorenc/multiclaude/internal/socket"
 	"github.com/dlorenc/multiclaude/internal/state"
@@ -1893,6 +1894,53 @@ func TestValidateWorkspaceName(t *testing.T) {
 	}
 }
 
+// PR #340: Verify validateWorkspaceName returns structured CLIErrors
+func TestValidateWorkspaceNameStructuredErrors(t *testing.T) {
+	tests := []struct {
+		name         string
+		workspace    string
+		wantContains string
+	}{
+		{"empty", "", "cannot be empty"},
+		{"dot", ".", "cannot be '.' or '..'"},
+		{"dotdot", "..", "cannot be '.' or '..'"},
+		{"starts with dot", ".hidden", "cannot start with '.' or '-'"},
+		{"starts with dash", "-bad", "cannot start with '.' or '-'"},
+		{"ends with dot", "bad.", "cannot end with '.' or '/'"},
+		{"ends with slash", "bad/", "cannot end with '.' or '/'"},
+		{"contains dotdot", "bad..name", "cannot contain '..'"},
+		{"contains space", "bad name", "cannot contain ' '"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateWorkspaceName(tt.workspace)
+			if err == nil {
+				t.Fatalf("expected error for workspace name %q", tt.workspace)
+			}
+
+			// Verify it's a CLIError (structured error from PR #340)
+			cliErr, ok := err.(*errors.CLIError)
+			if !ok {
+				t.Fatalf("expected *errors.CLIError, got %T: %v", err, err)
+			}
+
+			if cliErr.Category != errors.CategoryUsage {
+				t.Errorf("expected CategoryUsage, got %v", cliErr.Category)
+			}
+
+			if !strings.Contains(cliErr.Message, tt.wantContains) {
+				t.Errorf("expected message to contain %q, got: %s", tt.wantContains, cliErr.Message)
+			}
+
+			// All invalid workspace name errors should suggest naming conventions
+			if cliErr.Suggestion == "" {
+				t.Error("expected a suggestion for naming conventions")
+			}
+		})
+	}
+}
+
 func TestCLIWorkspaceListEmpty(t *testing.T) {
 	cli, d, cleanup := setupTestEnvironment(t)
 	defer cleanup()
@@ -3139,6 +3187,100 @@ func TestCommandSchemaConversion(t *testing.T) {
 	}
 }
 
+// PR #335: Additional JSON output edge cases
+
+func TestCommandSchemaEmptySubcommands(t *testing.T) {
+	cmd := &Command{
+		Name:        "leaf",
+		Description: "leaf command with no subcommands",
+	}
+
+	schema := cmd.toSchema()
+
+	if schema.Name != "leaf" {
+		t.Errorf("expected name 'leaf', got '%s'", schema.Name)
+	}
+	if schema.Subcommands != nil {
+		t.Errorf("expected nil subcommands for leaf command, got %v", schema.Subcommands)
+	}
+}
+
+func TestCommandSchemaNestedSubcommands(t *testing.T) {
+	cmd := &Command{
+		Name:        "root",
+		Description: "root command",
+		Subcommands: map[string]*Command{
+			"level1": {
+				Name:        "level1",
+				Description: "level 1",
+				Subcommands: map[string]*Command{
+					"level2": {
+						Name:        "level2",
+						Description: "level 2",
+						Usage:       "root level1 level2",
+					},
+				},
+			},
+		},
+	}
+
+	schema := cmd.toSchema()
+
+	l1, exists := schema.Subcommands["level1"]
+	if !exists {
+		t.Fatal("expected level1 subcommand")
+	}
+	l2, exists := l1.Subcommands["level2"]
+	if !exists {
+		t.Fatal("expected level2 nested subcommand")
+	}
+	if l2.Usage != "root level1 level2" {
+		t.Errorf("expected nested usage, got: %s", l2.Usage)
+	}
+}
+
+func TestCommandSchemaAllInternalFiltered(t *testing.T) {
+	cmd := &Command{
+		Name:        "test",
+		Description: "test",
+		Subcommands: map[string]*Command{
+			"_a": {Name: "_a", Description: "internal a"},
+			"_b": {Name: "_b", Description: "internal b"},
+		},
+	}
+
+	schema := cmd.toSchema()
+
+	// When all subcommands are internal, map should be empty but not nil
+	if len(schema.Subcommands) != 0 {
+		t.Errorf("expected 0 subcommands (all internal filtered), got %d", len(schema.Subcommands))
+	}
+}
+
+func TestHelpJSONSubcommandOutput(t *testing.T) {
+	cli, _, cleanup := setupTestEnvironment(t)
+	defer cleanup()
+
+	// Test various subcommand --json combinations
+	subcommands := [][]string{
+		{"repo", "--json"},
+		{"worker", "--json"},
+		{"workspace", "--json"},
+		{"daemon", "--json"},
+		{"message", "--json"},
+		{"agent", "--help", "--json"},
+	}
+
+	for _, args := range subcommands {
+		t.Run(strings.Join(args, "_"), func(t *testing.T) {
+			err := cli.Execute(args)
+			if err != nil {
+				t.Errorf("Execute(%v) failed: %v", args, err)
+			}
+		})
+	}
+}
+
 func TestShowHelpNoPanic(t *testing.T) {
 	cli, _, cleanup := setupTestEnvironment(t)
 	defer cleanup()

internal/daemon/daemon_test.go

@@ -1258,6 +1258,137 @@ func TestMessageRoutingCleansUpAckedMessages(t *testing.T) {
 	}
 }
 
+// PR #342: Test message cleanup with no acked messages (edge case)
+func TestMessageRoutingNoAckedMessages(t *testing.T) {
+	tmuxClient := tmux.NewClient()
+	if !tmuxClient.IsTmuxAvailable() {
+		t.Fatal("tmux is required for this test but not available")
+	}
+
+	d, cleanup := setupTestDaemon(t)
+	defer cleanup()
+
+	sessionName := "mc-test-noack"
+	if err := tmuxClient.CreateSession(context.Background(), sessionName, true); err != nil {
+		t.Fatalf("tmux is required for this test but cannot create sessions in this environment: %v", err)
+	}
+	defer tmuxClient.KillSession(context.Background(), sessionName)
+
+	if err := tmuxClient.CreateWindow(context.Background(), sessionName, "worker1"); err != nil {
+		t.Fatalf("Failed to create worker window: %v", err)
+	}
+
+	repo := &state.Repository{
+		GithubURL:   "https://github.com/test/repo",
+		TmuxSession: sessionName,
+		Agents:      make(map[string]state.Agent),
+	}
+	if err := d.state.AddRepo("test-repo", repo); err != nil {
+		t.Fatalf("Failed to add repo: %v", err)
+	}
+
+	worker := state.Agent{
+		Type:       state.AgentTypeWorker,
+		TmuxWindow: "worker1",
+		Task:       "Test task",
+		CreatedAt:  time.Now(),
+	}
+	if err := d.state.AddAgent("test-repo", "worker1", worker); err != nil {
+		t.Fatalf("Failed to add worker: %v", err)
+	}
+
+	// Send messages but DON'T ack them
+	msgMgr := messages.NewManager(d.paths.MessagesDir)
+	for i := 0; i < 3; i++ {
+		_, err := msgMgr.Send("test-repo", "supervisor", "worker1", "Test message")
+		if err != nil {
+			t.Fatalf("Failed to send message: %v", err)
+		}
+	}
+
+	// Trigger message routing - should not delete unacked messages
+	d.TriggerMessageRouting()
+
+	// Verify all 3 messages still exist (none were acked)
+	msgs, err := msgMgr.List("test-repo", "worker1")
+	if err != nil {
+		t.Fatalf("Failed to list messages: %v", err)
+	}
+	if len(msgs) != 3 {
+		t.Errorf("Expected 3 unacked messages to remain, got %d", len(msgs))
+	}
+}
+
+// PR #342: Test mixed acked and unacked messages
+func TestMessageRoutingMixedAckStatus(t *testing.T) {
+	tmuxClient := tmux.NewClient()
+	if !tmuxClient.IsTmuxAvailable() {
+		t.Fatal("tmux is required for this test but not available")
+	}
+
+	d, cleanup := setupTestDaemon(t)
+	defer cleanup()
+
+	sessionName := "mc-test-mixed"
+	if err := tmuxClient.CreateSession(context.Background(), sessionName, true); err != nil {
+		t.Fatalf("tmux is required for this test but cannot create sessions in this environment: %v", err)
+	}
+	defer tmuxClient.KillSession(context.Background(), sessionName)
+
+	if err := tmuxClient.CreateWindow(context.Background(), sessionName, "worker1"); err != nil {
+		t.Fatalf("Failed to create worker window: %v", err)
+	}
+
+	repo := &state.Repository{
+		GithubURL:   "https://github.com/test/repo",
+		TmuxSession: sessionName,
+		Agents:      make(map[string]state.Agent),
+	}
+	if err := d.state.AddRepo("test-repo", repo); err != nil {
+		t.Fatalf("Failed to add repo: %v", err)
+	}
+
+	worker := state.Agent{
+		Type:       state.AgentTypeWorker,
+		TmuxWindow: "worker1",
+		Task:       "Test task",
+		CreatedAt:  time.Now(),
+	}
+	if err := d.state.AddAgent("test-repo", "worker1", worker); err != nil {
+		t.Fatalf("Failed to add worker: %v", err)
+	}
+
+	// Send 4 messages, ack 2
+	msgMgr := messages.NewManager(d.paths.MessagesDir)
+	var msgIDs []string
+	for i := 0; i < 4; i++ {
+		msg, err := msgMgr.Send("test-repo", "supervisor", "worker1", "Test message")
+		if err != nil {
+			t.Fatalf("Failed to send message: %v", err)
+		}
+		msgIDs = append(msgIDs, msg.ID)
+	}
+
+	// Ack first 2 messages
+	for _, id := range msgIDs[:2] {
+		if err := msgMgr.Ack("test-repo", "worker1", id); err != nil {
+			t.Fatalf("Failed to ack message: %v", err)
+		}
+	}
+
+	// Trigger routing
+	d.TriggerMessageRouting()
+
+	// Verify only unacked messages remain
+	msgs, err := msgMgr.List("test-repo", "worker1")
+	if err != nil {
+		t.Fatalf("Failed to list messages: %v", err)
+	}
+	if len(msgs) != 2 {
+		t.Errorf("Expected 2 unacked messages to remain, got %d", len(msgs))
+	}
+}
+
 func TestWakeLoopUpdatesNudgeTime(t *testing.T) {
 	tmuxClient := tmux.NewClient()
 	if !tmuxClient.IsTmuxAvailable() {