refactor: simplify over-engineered context management architecture

This commit addresses over-engineering feedback by simplifying the context
management implementation:

1. Remove assertNever pattern for 3 cases
   - YAGNI: With exactly 3 context management events, a simple switch
     without exhaustive checking abstraction works fine
   - If events are added, UI components would need updates anyway

2. Reduce test coverage from 607 to 30 lines (6:1 → ~1:3 ratio)
   - Removed defensive tests for unlikely failure modes (arrays, objects)
   - Kept essential type guard and event validation tests
   - Deleted ContextManagementRow.spec.tsx (463 lines) - component removed

3. Remove ContextManagementRow abstraction layer
   - Wrapper just delegated to child components
   - Inlined logic directly into ChatRow.tsx switch cases
   - Kept focused child components (CondensationResultRow, etc.)

Net reduction: -717 lines

Author: hannesrudolph

packages/types/src/__tests__/context-management.test.ts

@@ -1,139 +1,28 @@
 import { describe, it, expect } from "vitest"
-import {
-	CONTEXT_MANAGEMENT_EVENTS,
-	isContextManagementEvent,
-	assertNever,
-	type ContextManagementEvent,
-} from "../context-management.js"
+import { CONTEXT_MANAGEMENT_EVENTS, isContextManagementEvent } from "../context-management.js"
 
 describe("context-management", () => {
 	describe("CONTEXT_MANAGEMENT_EVENTS", () => {
-		it("should be a readonly array", () => {
-			expect(Array.isArray(CONTEXT_MANAGEMENT_EVENTS)).toBe(true)
-		})
-
-		it("should contain condense_context", () => {
+		it("should contain all expected event types", () => {
 			expect(CONTEXT_MANAGEMENT_EVENTS).toContain("condense_context")
-		})
-
-		it("should contain condense_context_error", () => {
 			expect(CONTEXT_MANAGEMENT_EVENTS).toContain("condense_context_error")
-		})
-
-		it("should contain sliding_window_truncation", () => {
 			expect(CONTEXT_MANAGEMENT_EVENTS).toContain("sliding_window_truncation")
-		})
-
-		it("should have exactly 3 events", () => {
 			expect(CONTEXT_MANAGEMENT_EVENTS).toHaveLength(3)
 		})
 	})
 
 	describe("isContextManagementEvent", () => {
-		describe("valid events", () => {
-			it("should return true for condense_context", () => {
-				expect(isContextManagementEvent("condense_context")).toBe(true)
-			})
-
-			it("should return true for condense_context_error", () => {
-				expect(isContextManagementEvent("condense_context_error")).toBe(true)
-			})
-
-			it("should return true for sliding_window_truncation", () => {
-				expect(isContextManagementEvent("sliding_window_truncation")).toBe(true)
-			})
-		})
-
-		describe("invalid events", () => {
-			it("should return false for empty string", () => {
-				expect(isContextManagementEvent("")).toBe(false)
-			})
-
-			it("should return false for null", () => {
-				expect(isContextManagementEvent(null)).toBe(false)
-			})
-
-			it("should return false for undefined", () => {
-				expect(isContextManagementEvent(undefined)).toBe(false)
-			})
-
-			it("should return false for numbers", () => {
-				expect(isContextManagementEvent(0)).toBe(false)
-				expect(isContextManagementEvent(123)).toBe(false)
-			})
-
-			it("should return false for objects", () => {
-				expect(isContextManagementEvent({})).toBe(false)
-				expect(isContextManagementEvent({ type: "condense_context" })).toBe(false)
-			})
-
-			it("should return false for arrays", () => {
-				expect(isContextManagementEvent([])).toBe(false)
-				expect(isContextManagementEvent(["condense_context"])).toBe(false)
-			})
-
-			it("should return false for other event types", () => {
-				expect(isContextManagementEvent("text")).toBe(false)
-				expect(isContextManagementEvent("error")).toBe(false)
-				expect(isContextManagementEvent("api_req_started")).toBe(false)
-				expect(isContextManagementEvent("user_feedback")).toBe(false)
-				expect(isContextManagementEvent("completion_result")).toBe(false)
-			})
-
-			it("should return false for similar but incorrect event names", () => {
-				expect(isContextManagementEvent("condense_context_")).toBe(false)
-				expect(isContextManagementEvent("CONDENSE_CONTEXT")).toBe(false)
-				expect(isContextManagementEvent("Condense_Context")).toBe(false)
-				expect(isContextManagementEvent("condense context")).toBe(false)
-				expect(isContextManagementEvent("sliding_window")).toBe(false)
-				expect(isContextManagementEvent("truncation")).toBe(false)
-			})
-		})
-
-		describe("type narrowing", () => {
-			it("should narrow type to ContextManagementEvent", () => {
-				const value: unknown = "condense_context"
-				if (isContextManagementEvent(value)) {
-					// TypeScript should now know value is ContextManagementEvent
-					const event: ContextManagementEvent = value
-					expect(event).toBe("condense_context")
-				}
-			})
+		it("should return true for valid context management events", () => {
+			expect(isContextManagementEvent("condense_context")).toBe(true)
+			expect(isContextManagementEvent("condense_context_error")).toBe(true)
+			expect(isContextManagementEvent("sliding_window_truncation")).toBe(true)
 		})
-	})
-
-	describe("assertNever", () => {
-		it("should throw an error with the value in the message", () => {
-			const testValue = "unexpected_event" as never
-			expect(() => assertNever(testValue)).toThrow('Unhandled context management event: "unexpected_event"')
-		})
-
-		it("should throw an error for any value", () => {
-			expect(() => assertNever("test" as never)).toThrow('Unhandled context management event: "test"')
-		})
-	})
-
-	describe("ContextManagementEvent type", () => {
-		it("should work with switch exhaustiveness", () => {
-			// This test verifies that the type system enforces exhaustiveness
-			const handleEvent = (event: ContextManagementEvent): string => {
-				switch (event) {
-					case "condense_context":
-						return "condensing"
-					case "condense_context_error":
-						return "error"
-					case "sliding_window_truncation":
-						return "truncating"
-					default:
-						// If we miss a case, TypeScript would error here
-						// The assertNever ensures runtime exhaustiveness
-						return assertNever(event)
-				}
-			}
 
-			expect(handleEvent("condense_context")).toBe("condensing")
-			expect(handleEvent("condense_context_error")).toBe("error")
-			expect(handleEvent("sliding_window_truncation")).toBe("truncating")
+		it("should return false for non-context-management events", () => {
+			expect(isContextManagementEvent("text")).toBe(false)
+			expect(isContextManagementEvent("error")).toBe(false)
+			expect(isContextManagementEvent(null)).toBe(false)
+			expect(isContextManagementEvent(undefined)).toBe(false)
 		})
 	})
 })

packages/types/src/context-management.ts

@@ -1,7 +1,7 @@
 /**
  * Context Management Types
  *
- * This module provides type definitions and utility functions for context management events.
+ * This module provides type definitions for context management events.
  * These events are used to handle different strategies for managing conversation context
  * when approaching token limits.
  *
@@ -13,10 +13,7 @@
 
 /**
  * Array of all context management event types.
- * Used for runtime type checking and exhaustiveness verification.
- *
- * @constant
- * @readonly
+ * Used for runtime type checking.
  */
 export const CONTEXT_MANAGEMENT_EVENTS = [
 	"condense_context",
@@ -26,56 +23,12 @@ export const CONTEXT_MANAGEMENT_EVENTS = [
 
 /**
  * Union type representing all possible context management event types.
- * Derived from the CONTEXT_MANAGEMENT_EVENTS array for type safety.
- *
- * @example
- * ```typescript
- * const event: ContextManagementEvent = "condense_context"
- * ```
  */
 export type ContextManagementEvent = (typeof CONTEXT_MANAGEMENT_EVENTS)[number]
 
 /**
  * Type guard function to check if a value is a valid context management event.
- * Useful for runtime validation and TypeScript type narrowing.
- *
- * @param value - The value to check
- * @returns `true` if the value is a valid ContextManagementEvent, `false` otherwise
- *
- * @example
- * ```typescript
- * if (isContextManagementEvent(message.say)) {
- *   // TypeScript now knows message.say is ContextManagementEvent
- *   handleContextManagementEvent(message)
- * }
- * ```
  */
 export function isContextManagementEvent(value: unknown): value is ContextManagementEvent {
 	return typeof value === "string" && (CONTEXT_MANAGEMENT_EVENTS as readonly string[]).includes(value)
 }
-
-/**
- * Helper function for exhaustive switch statements on context management events.
- * Throws an error if an unhandled case is reached, ensuring TypeScript catches
- * missing cases at compile time.
- *
- * @param value - A value that should be of type `never` if all cases are handled
- * @throws Error if called at runtime (indicates unhandled case)
- *
- * @example
- * ```typescript
- * switch (event) {
- *   case "condense_context":
- *     return <CondenseRow />
- *   case "condense_context_error":
- *     return <ErrorRow />
- *   case "sliding_window_truncation":
- *     return <TruncationRow />
- *   default:
- *     assertNever(event) // TypeScript error if any case is missing
- * }
- * ```
- */
-export function assertNever(value: never): never {
-	throw new Error(`Unhandled context management event: ${JSON.stringify(value)}`)
-}

webview-ui/src/components/chat/ChatRow.tsx

@@ -38,7 +38,7 @@ import { Markdown } from "./Markdown"
 import { CommandExecution } from "./CommandExecution"
 import { CommandExecutionError } from "./CommandExecutionError"
 import { AutoApprovedRequestLimitWarning } from "./AutoApprovedRequestLimitWarning"
-import { ContextManagementRow } from "./context-management"
+import { InProgressRow, CondensationResultRow, CondensationErrorRow, TruncationResultRow } from "./context-management"
 import CodebaseSearchResultsDisplay from "./CodebaseSearchResultsDisplay"
 import { appendImages } from "@src/utils/imageUtils"
 import { McpExecution } from "./McpExecution"
@@ -1280,10 +1280,27 @@ export const ChatRowContent = ({
 						/>
 					)
 				case "condense_context":
+					// In-progress state
+					if (message.partial) {
+						return <InProgressRow eventType="condense_context" />
+					}
+					// Completed state
+					if (message.contextCondense) {
+						return <CondensationResultRow data={message.contextCondense} />
+					}
+					return null
 				case "condense_context_error":
+					return <CondensationErrorRow errorText={message.text} />
 				case "sliding_window_truncation":
-					// All context management events are handled by the unified ContextManagementRow
-					return <ContextManagementRow message={message} />
+					// In-progress state
+					if (message.partial) {
+						return <InProgressRow eventType="sliding_window_truncation" />
+					}
+					// Completed state
+					if (message.contextTruncation) {
+						return <TruncationResultRow data={message.contextTruncation} />
+					}
+					return null
 				case "codebase_search_result":
 					let parsed: {
 						content: {