Fix CLI status filtering and add status exclusion support

Status aliases now store numeric IDs instead of names, fixing silent
filter failures where strconv.Atoi("Done") would fail on the server.
Add status_id_not query param for negation filtering (~done), a
completed-statuses endpoint for fallback resolution when aliases are
stale, and a ws config refresh command to regenerate aliases.

Author: stefan-ernst

RELEASE_NOTES.md

@@ -1,4 +1,4 @@
-# Windshift v0.4.5
+# Windshift v0.4.6
 
 ---
 
@@ -12,25 +12,27 @@
 
 ## Highlights
 
-### Improved Onboarding for Non-Admin Users
-The onboarding flow now handles non-admin users who already have access to a workspace. Previously, these users could get stuck in the onboarding process; they are now guided directly into their available workspace.
+### Fixed CLI Status Filtering
+Status filtering in the CLI (`ws task list -s done`, `ws task mine -s ~done`) was silently broken because aliases stored status names instead of numeric IDs. The server's `status_id` parameter requires an integer, so name-based values were quietly ignored. Aliases now store numeric status IDs, and a fallback mechanism queries the server's completed-statuses endpoint when aliases are stale or missing.
 
-### Searchable Multi-Select for Iteration Filters
-The CQL iteration `IN` / `NOT IN` filter UI has been upgraded from a plain checkbox list to a searchable multi-select dropdown, making it much easier to work with long lists of iterations.
+### Status Exclusion Filter (`~done`)
+The CLI's negation syntax (`-s ~done`) now works end-to-end. A new `status_id_not` query parameter has been added to the items API, enabling server-side exclusion of a specific status.
 
-### Resizable Collections Sidebar
-The collections sidebar can now be resized by dragging a handle on its edge, giving you control over how much screen space it occupies.
+### Completed Statuses Endpoint
+A new `GET /rest/api/v1/workspaces/{id}/statuses/completed` endpoint returns only statuses where the category is marked as completed. This powers the CLI's fallback resolution and is available for any integration that needs to identify "done" statuses programmatically.
 
-### Workspace Key Cache
-Workspace key resolution no longer requires a database lookup on every request. Keys are now cached in memory, improving response times for all workspace-scoped API calls.
+### `ws config refresh` Command
+A new `ws config refresh` subcommand re-fetches workspace statuses from the server and regenerates status aliases with numeric IDs in `ws.toml`. Use this after renaming statuses on the server to keep your local aliases in sync.
 
 ---
 
 ## Bug Fixes
 
-- **CQL Iteration Filter:** Fixed iteration `IN` / `NOT IN` queries and corrected user group name resolution in CQL
-- **PostgreSQL Notification Settings:** Fixed notification settings queries and the config set admin page failing on PostgreSQL
+- **Status filter silently ignored:** `ws task list -s done` now correctly sends numeric status IDs to the server instead of status names that fail `strconv.Atoi` silently
+- **Negation filter no-op:** `ws task list -s ~done` now excludes the specified status via the new `status_id_not` server-side filter
+- **Stale alias resilience:** If a status is renamed after `ws init`, the CLI falls back to the completed-statuses endpoint to resolve "done" dynamically
 
-## Other Changes
+## API Changes
 
-- Split large handler files into smaller, focused modules (planning, Jira importer, SCM, portal, AI)
+- Added `status_id_not` query parameter to `GET /rest/api/v1/items` for excluding items by status
+- Added `GET /rest/api/v1/workspaces/{id}/statuses/completed` endpoint

cmd/ws/client.go

@@ -227,6 +227,15 @@ func (c *Client) GetWorkspaceStatuses(workspaceID int) ([]Status, error) {
 	return statuses, nil
 }
 
+// GetCompletedStatuses gets statuses where is_completed = true for a workspace
+func (c *Client) GetCompletedStatuses(workspaceID int) ([]Status, error) {
+	var statuses []Status
+	if err := c.GET(fmt.Sprintf("/rest/api/v1/workspaces/%d/statuses/completed", workspaceID), &statuses); err != nil {
+		return nil, err
+	}
+	return statuses, nil
+}
+
 // ListStatuses lists all statuses
 func (c *Client) ListStatuses() ([]Status, error) {
 	var statuses []Status

cmd/ws/config.go

@@ -144,6 +144,38 @@ func (c *Config) ResolveStatus(input string) string {
 	return input
 }
 
+// ResolveStatusWithFallback resolves a status input, falling back to the completed-statuses
+// endpoint when the alias is non-numeric (stale) or when "done" has no alias.
+// Returns comma-separated IDs for completed statuses, or the resolved value.
+func (c *Config) ResolveStatusWithFallback(input string, client *Client) string {
+	resolved := c.ResolveStatus(input)
+
+	// If already numeric, use it directly
+	if _, err := fmt.Sscanf(resolved, "%d", new(int)); err == nil {
+		return resolved
+	}
+
+	// Non-numeric resolution — try completed-statuses endpoint for "done" alias
+	if input == "done" || resolved == "done" {
+		wsKey := c.GetEffectiveWorkspace()
+		if wsKey == "" {
+			return resolved
+		}
+		wsID, err := client.ResolveWorkspaceID(wsKey)
+		if err != nil {
+			return resolved
+		}
+		statuses, err := client.GetCompletedStatuses(wsID)
+		if err != nil || len(statuses) == 0 {
+			return resolved
+		}
+		// Return first completed status ID
+		return fmt.Sprintf("%d", statuses[0].ID)
+	}
+
+	return resolved
+}
+
 // GetEffectiveWorkspace returns the workspace key to use for queries
 func (c *Config) GetEffectiveWorkspace() string {
 	return c.Defaults.WorkspaceKey

cmd/ws/config_cmd.go

@@ -223,12 +223,66 @@ This shows the merged configuration from all sources:
 	},
 }
 
+var configRefreshCmd = &cobra.Command{
+	Use:   "refresh",
+	Short: "Refresh status aliases from workspace",
+	Long: `Re-fetch workspace statuses and regenerate status aliases with numeric IDs.
+
+This is useful when statuses have been renamed on the server or when aliases
+contain stale name-based values instead of numeric IDs.
+
+Examples:
+  ws config refresh                       # Refresh aliases in ./ws.toml`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		client, err := NewClient()
+		if err != nil {
+			return err
+		}
+
+		wsKey := cfg.GetEffectiveWorkspace()
+		if wsKey == "" {
+			return fmt.Errorf("workspace is required: use -w flag or set defaults.workspace_key in config")
+		}
+
+		wsID, err := client.ResolveWorkspaceID(wsKey)
+		if err != nil {
+			return fmt.Errorf("failed to resolve workspace: %w", err)
+		}
+
+		statuses, err := client.GetWorkspaceStatuses(wsID)
+		if err != nil {
+			return fmt.Errorf("failed to get statuses: %w", err)
+		}
+
+		// Regenerate aliases with numeric IDs
+		cfg.StatusAliases = generateDefaultAliases(statuses)
+
+		// Save back to project config
+		projectConfig := Config{
+			Server:        cfg.Server,
+			Defaults:      cfg.Defaults,
+			Cache:         cfg.Cache,
+			StatusAliases: cfg.StatusAliases,
+		}
+		if err := saveProjectConfig(projectConfig, "./ws.toml"); err != nil {
+			return fmt.Errorf("failed to save ws.toml: %w", err)
+		}
+
+		fmt.Println("Refreshed status aliases in ws.toml:")
+		for alias, id := range cfg.StatusAliases {
+			fmt.Printf("  %s -> %s\n", alias, id)
+		}
+		return nil
+	},
+}
+
 var configInitGlobal bool
 
 func init() {
 	rootCmd.AddCommand(configCmd)
 	configCmd.AddCommand(configInitCmd)
 	configCmd.AddCommand(configShowCmd)
+	configCmd.AddCommand(configRefreshCmd)
 
 	configInitCmd.Flags().BoolVar(&configInitGlobal, "global", false, "create global config instead of project config")
 }

cmd/ws/init.go

@@ -250,38 +250,40 @@ func generateDefaultAliases(statuses []Status) map[string]string {
 	for _, s := range statuses {
 		nameLower := strings.ToLower(s.Name)
 
+		idStr := fmt.Sprintf("%d", s.ID)
+
 		// Map "done" alias
 		if strings.Contains(nameLower, "done") || strings.Contains(nameLower, "complete") {
 			if _, exists := aliases["done"]; !exists {
-				aliases["done"] = s.Name
+				aliases["done"] = idStr
 			}
 		}
 
 		// Map "progress" alias
 		if strings.Contains(nameLower, "progress") || strings.Contains(nameLower, "working") {
 			if _, exists := aliases["progress"]; !exists {
-				aliases["progress"] = s.Name
+				aliases["progress"] = idStr
 			}
 		}
 
 		// Map "blocked" alias
 		if strings.Contains(nameLower, "block") || strings.Contains(nameLower, "hold") {
 			if _, exists := aliases["blocked"]; !exists {
-				aliases["blocked"] = s.Name
+				aliases["blocked"] = idStr
 			}
 		}
 
 		// Map "review" alias
 		if strings.Contains(nameLower, "review") {
 			if _, exists := aliases["review"]; !exists {
-				aliases["review"] = s.Name
+				aliases["review"] = idStr
 			}
 		}
 
 		// Map "todo" alias
 		if strings.Contains(nameLower, "open") || strings.Contains(nameLower, "new") || strings.Contains(nameLower, "todo") {
 			if _, exists := aliases["todo"]; !exists {
-				aliases["todo"] = s.Name
+				aliases["todo"] = idStr
 			}
 		}
 	}

cmd/ws/task.go

@@ -53,10 +53,10 @@ Examples:
 		// Add optional filters from flags
 		if statusFilter != "" {
 			if isNegatedFilter(statusFilter) {
-				resolved := cfg.ResolveStatus(stripNegation(statusFilter))
+				resolved := cfg.ResolveStatusWithFallback(stripNegation(statusFilter), client)
 				filters["status_id_not"] = resolved
 			} else {
-				resolved := cfg.ResolveStatus(statusFilter)
+				resolved := cfg.ResolveStatusWithFallback(statusFilter, client)
 				filters["status_id"] = resolved
 			}
 		}
@@ -174,10 +174,10 @@ Examples:
 		if statusFilter != "" {
 			if isNegatedFilter(statusFilter) {
 				// Negation: exclude this status
-				resolved := cfg.ResolveStatus(stripNegation(statusFilter))
+				resolved := cfg.ResolveStatusWithFallback(stripNegation(statusFilter), client)
 				filters["status_id_not"] = resolved
 			} else {
-				resolved := cfg.ResolveStatus(statusFilter)
+				resolved := cfg.ResolveStatusWithFallback(statusFilter, client)
 				filters["status_id"] = resolved
 			}
 		}

frontend/src/version.json

@@ -1 +1 @@
-{"code": "v0.4.5", "name": "Early Outfitting"}
+{"code": "v0.4.6", "name": "Early Outfitting"}

internal/repository/item_list.go

@@ -23,6 +23,7 @@ type ItemListParams struct {
 type ItemFilters struct {
 	WorkspaceID   *int
 	StatusID      *int
+	StatusIDNot   *int
 	PriorityID    *int
 	AssigneeID    *int
 	CreatorID     *int
@@ -193,6 +194,11 @@ func (r *ItemRepository) buildWhereClause(params ItemListParams) (whereClause st
 		args = append(args, *params.Filters.StatusID)
 	}
 
+	if params.Filters.StatusIDNot != nil {
+		whereClause += " AND i.status_id != ?"
+		args = append(args, *params.Filters.StatusIDNot)
+	}
+
 	if params.Filters.PriorityID != nil {
 		whereClause += " AND i.priority_id = ?"
 		args = append(args, *params.Filters.PriorityID)

internal/restapi/v1/handlers/items.go

@@ -118,6 +118,11 @@ func (h *ItemHandler) List(w http.ResponseWriter, r *http.Request) {
 			filters.StatusID = &id
 		}
 	}
+	if statusIDNot := r.URL.Query().Get("status_id_not"); statusIDNot != "" {
+		if id, parseErr := strconv.Atoi(statusIDNot); parseErr == nil {
+			filters.StatusIDNot = &id
+		}
+	}
 	if priorityID := r.URL.Query().Get("priority_id"); priorityID != "" {
 		if id, parseErr := strconv.Atoi(priorityID); parseErr == nil {
 			filters.PriorityID = &id

internal/restapi/v1/handlers/workspaces.go

@@ -390,6 +390,52 @@ func (h *WorkspaceHandler) GetStatuses(w http.ResponseWriter, r *http.Request) {
 	restapi.RespondOK(w, result)
 }
 
+// ListCompletedStatuses handles GET /rest/api/v1/workspaces/{id}/statuses/completed
+func (h *WorkspaceHandler) ListCompletedStatuses(w http.ResponseWriter, r *http.Request) {
+	user, ok := requireAuth(w, r)
+	if !ok {
+		return
+	}
+
+	wsID, ok := parsePathID(w, r, "id", "workspace ID")
+	if !ok {
+		return
+	}
+
+	canView, _ := h.perms.CanViewWorkspace(user.ID, wsID)
+	if !canView {
+		restapi.RespondError(w, r, restapi.ErrWorkspaceNotFound)
+		return
+	}
+
+	statuses, err := h.workspaceService.GetStatuses(wsID)
+	if err != nil {
+		restapi.RespondError(w, r, restapi.ErrInternalError)
+		return
+	}
+
+	// Filter for completed statuses only
+	var result []dto.StatusSummary
+	for _, s := range statuses {
+		if s.IsCompleted {
+			result = append(result, dto.StatusSummary{
+				ID:            s.ID,
+				Name:          s.Name,
+				CategoryID:    s.CategoryID,
+				CategoryName:  s.CategoryName,
+				CategoryColor: s.CategoryColor,
+				IsCompleted:   s.IsCompleted,
+			})
+		}
+	}
+
+	if result == nil {
+		result = []dto.StatusSummary{}
+	}
+
+	restapi.RespondOK(w, result)
+}
+
 // GetItemTypes handles GET /rest/api/v1/workspaces/{id}/item-types
 func (h *WorkspaceHandler) GetItemTypes(w http.ResponseWriter, r *http.Request) {
 	user, ok := requireAuth(w, r)