reducers.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

// allow-any-unicode-comment-file
// DO NOT EDIT -- auto-generated by scripts/sync-agent-host-protocol.ts

import { ActionType } from './actions.js';
import { SessionLifecycle, SessionStatus, TurnState, ToolCallStatus, ToolCallConfirmationReason, ToolCallCancellationReason, ResponsePartKind, PendingMessageKind, type RootState, type SessionInputRequest, type SessionState, type TerminalState, type TerminalContentPart, type ToolCallState, type ResponsePart, type ToolCallResponsePart, type Turn, type PendingMessage, type ConfirmationOption } from './state.js';
import { IS_CLIENT_DISPATCHABLE, type RootAction, type ClientRootAction, type SessionAction, type ClientSessionAction, type TerminalAction, type ClientTerminalAction } from './action-origin.generated.js';

// ─── Helpers ─────────────────────────────────────────────────────────────────

/**
 * Soft assertion for exhaustiveness checking. Place in the `default` branch of
 * a switch on a discriminated union so the compiler errors when a new variant
 * is added but not handled.
 *
 * At runtime, logs a warning instead of throwing so that forward-compatible
 * clients receiving unknown actions from a newer server degrade gracefully.
 */
export function softAssertNever(value: never, log?: (msg: string) => void): void {
	const msg = `Unhandled action type: ${JSON.stringify(value)}`;
	(log ?? console.warn)(msg);
}

/** Extracts the common base fields shared by all tool call lifecycle states. */
function tcBase(tc: ToolCallState) {
	return {
		toolCallId: tc.toolCallId,
		toolName: tc.toolName,
		displayName: tc.displayName,
		toolClientId: tc.toolClientId,
		_meta: tc._meta,
	};
}

/** Resolves a selected option from the confirmation options array by ID. */
function resolveSelectedOption(options: ConfirmationOption[] | undefined, id: string | undefined): ConfirmationOption | undefined {
	if (!id || !options) {
		return undefined;
	}
	return options.find(o => o.id === id);
}

/** Returns `true` if the active turn has any tool call awaiting user confirmation. */
function hasPendingToolCallConfirmation(state: SessionState): boolean {
	if (!state.activeTurn) {
		return false;
	}
	return state.activeTurn.responseParts.some(part =>
		part.kind === ResponsePartKind.ToolCall
		&& (part.toolCall.status === ToolCallStatus.PendingConfirmation
			|| part.toolCall.status === ToolCallStatus.PendingResultConfirmation),
	);
}

/** Bitmask covering the mutually-exclusive activity bits (bits 0–4). */
const STATUS_ACTIVITY_MASK = (1 << 5) - 1;

/** Sets or clears a metadata flag on a status value. */
function withStatusFlag(status: SessionStatus, flag: SessionStatus, set: boolean): SessionStatus {
	return set ? status | flag : status & ~flag;
}

/** Derives the summary status from live session work, preserving orthogonal flags. */
function summaryStatus(state: SessionState, terminalStatus?: SessionStatus.Error): SessionStatus {
	let activity: SessionStatus;
	if (terminalStatus) {
		activity = terminalStatus;
	} else if ((state.inputRequests?.length ?? 0) > 0 || hasPendingToolCallConfirmation(state)) {
		activity = SessionStatus.InputNeeded;
	} else if (state.activeTurn) {
		activity = SessionStatus.InProgress;
	} else {
		activity = SessionStatus.Idle;
	}

	return state.summary.status & ~STATUS_ACTIVITY_MASK | activity;
}

/**
 * Returns a state with `summary.status` recomputed. Use this after reducers
 * that change data which feeds into {@link summaryStatus} (e.g. tool call
 * lifecycle transitions that may enter or leave a pending-confirmation state).
 */
function refreshSummaryStatus(state: SessionState): SessionState {
	const status = summaryStatus(state);
	if (status === state.summary.status) {
		return state;
	}
	return { ...state, summary: { ...state.summary, status } };
}

/**
 * Ends the active turn, finalizing it into a completed turn record.
 *
 * Tool call parts with non-terminal states are forced to cancelled.
 * Pending permissions are stripped from tool call parts.
 */
function endTurn(
	state: SessionState,
	turnId: string,
	turnState: TurnState,
	terminalStatus?: SessionStatus.Error,
	error?: { errorType: string; message: string; stack?: string },
): SessionState {
	if (!state.activeTurn || state.activeTurn.id !== turnId) {
		return state;
	}
	const active = state.activeTurn;

	const responseParts: ResponsePart[] = active.responseParts.map(part => {
		if (part.kind !== ResponsePartKind.ToolCall) {
			return part;
		}
		const tc = part.toolCall;
		if (tc.status === ToolCallStatus.Completed || tc.status === ToolCallStatus.Cancelled) {
			return part;
		}
		// Force non-terminal tool calls into cancelled state
		return {
			kind: ResponsePartKind.ToolCall,
			toolCall: {
				status: ToolCallStatus.Cancelled as const,
				...tcBase(tc),
				invocationMessage: tc.status === ToolCallStatus.Streaming ? (tc.invocationMessage ?? '') : tc.invocationMessage,
				toolInput: tc.status === ToolCallStatus.Streaming ? undefined : tc.toolInput,
				reason: ToolCallCancellationReason.Skipped,
			},
		};
	});

	const turn: Turn = {
		id: active.id,
		userMessage: active.userMessage,
		responseParts,
		usage: active.usage,
		state: turnState,
		error,
	};

	const next: SessionState = {
		...state,
		turns: [...state.turns, turn],
		activeTurn: undefined,
		summary: { ...state.summary, modifiedAt: Date.now() },
	};
	delete next.inputRequests;
	return {
		...next,
		summary: { ...next.summary, status: summaryStatus(next, terminalStatus) },
	};
}

function upsertInputRequest(state: SessionState, request: SessionInputRequest): SessionState {
	const existing = state.inputRequests ?? [];
	const idx = existing.findIndex(r => r.id === request.id);
	const inputRequests = [...existing];
	if (idx >= 0) {
		const answers = request.answers ?? inputRequests[idx].answers;
		inputRequests[idx] = { ...request, answers };
	} else {
		inputRequests.push(request);
	}
	const next = { ...state, inputRequests };
	return { ...next, summary: { ...next.summary, status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false), modifiedAt: Date.now() } };
}

/**
 * Immutably updates the tool call inside a `ToolCall` response part in the
 * active turn's `responseParts` array. Returns `state` unchanged if the
 * active turn or tool call doesn't match.
 */
function updateToolCallInParts(
	state: SessionState,
	turnId: string,
	toolCallId: string,
	updater: (tc: ToolCallState) => ToolCallState,
): SessionState {
	const activeTurn = state.activeTurn;
	if (!activeTurn || activeTurn.id !== turnId) {
		return state;
	}

	let found = false;
	const responseParts = activeTurn.responseParts.map(part => {
		if (part.kind === ResponsePartKind.ToolCall && part.toolCall.toolCallId === toolCallId) {
			const updated = updater(part.toolCall);
			if (updated === part.toolCall) {
				return part;
			}
			found = true;
			return { ...part, toolCall: updated };
		}
		return part;
	});

	if (!found) {
		return state;
	}

	return {
		...state,
		activeTurn: { ...activeTurn, responseParts },
	};
}

/**
 * Immutably updates a response part by `partId` in the active turn.
 * For markdown/reasoning parts, matches on `id`. For tool call parts,
 * matches on `toolCall.toolCallId`.
 */
function updateResponsePart(
	state: SessionState,
	turnId: string,
	partId: string,
	updater: (part: ResponsePart) => ResponsePart,
): SessionState {
	const activeTurn = state.activeTurn;
	if (!activeTurn || activeTurn.id !== turnId) {
		return state;
	}

	let found = false;
	const responseParts = activeTurn.responseParts.map(part => {
		if (!found) {
			const id = part.kind === ResponsePartKind.ToolCall
				? part.toolCall.toolCallId
				: 'id' in part ? part.id : undefined;
			if (id === partId) {
				found = true;
				return updater(part);
			}
		}
		return part;
	});

	if (!found) {
		return state;
	}

	return {
		...state,
		activeTurn: { ...activeTurn, responseParts },
	};
}

// ─── Root Reducer ────────────────────────────────────────────────────────────

/**
 * Pure reducer for root state. Handles all {@link RootAction} variants.
 */
export function rootReducer(state: RootState, action: RootAction, log?: (msg: string) => void): RootState {
	switch (action.type) {
		case ActionType.RootAgentsChanged:
			return { ...state, agents: action.agents };

		case ActionType.RootActiveSessionsChanged:
			return { ...state, activeSessions: action.activeSessions };

		case ActionType.RootTerminalsChanged:
			return { ...state, terminals: action.terminals };

		case ActionType.RootConfigChanged:
			if (!state.config) {
				return state;
			}
			return {
				...state,
				config: {
					...state.config,
					values: action.replace ? { ...action.config } : { ...state.config.values, ...action.config },
				},
			};

		default:
			softAssertNever(action, log);
			return state;
	}
}

// ─── Session Reducer ─────────────────────────────────────────────────────────

/**
 * Pure reducer for session state. Handles all {@link SessionAction} variants.
 */
export function sessionReducer(state: SessionState, action: SessionAction, log?: (msg: string) => void): SessionState {
	switch (action.type) {
		// ── Lifecycle ──────────────────────────────────────────────────────────

		case ActionType.SessionReady:
			return {
				...state,
				lifecycle: SessionLifecycle.Ready,
				summary: { ...state.summary, status: SessionStatus.Idle },
			};

		case ActionType.SessionCreationFailed:
			return {
				...state,
				lifecycle: SessionLifecycle.CreationFailed,
				creationError: action.error,
			};

		// ── Turn Lifecycle ────────────────────────────────────────────────────

		case ActionType.SessionTurnStarted: {
			let next: SessionState = {
				...state,
				activeTurn: {
					id: action.turnId,
					userMessage: action.userMessage,
					responseParts: [],
					usage: undefined,
				},
			};
			next = {
				...next,
				summary: { ...next.summary, status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false), modifiedAt: Date.now() },
			};

			// If this turn was auto-started from a pending message, remove it
			if (action.queuedMessageId) {
				if (next.steeringMessage?.id === action.queuedMessageId) {
					next = { ...next, steeringMessage: undefined };
				}
				if (next.queuedMessages) {
					const filtered = next.queuedMessages.filter(m => m.id !== action.queuedMessageId);
					next = { ...next, queuedMessages: filtered.length > 0 ? filtered : undefined };
				}
			}

			return next;
		}

		case ActionType.SessionDelta:
			return updateResponsePart(state, action.turnId, action.partId, part => {
				if (part.kind === ResponsePartKind.Markdown) {
					return { ...part, content: part.content + action.content };
				}
				return part;
			});

		case ActionType.SessionResponsePart:
			if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
				return state;
			}
			return {
				...state,
				activeTurn: {
					...state.activeTurn,
					responseParts: [...state.activeTurn.responseParts, action.part],
				},
			};

		case ActionType.SessionTurnComplete:
			return endTurn(state, action.turnId, TurnState.Complete);

		case ActionType.SessionTurnCancelled:
			return endTurn(state, action.turnId, TurnState.Cancelled);

		case ActionType.SessionError:
			return endTurn(state, action.turnId, TurnState.Error, SessionStatus.Error, action.error);

		// ── Tool Call State Machine ───────────────────────────────────────────

		case ActionType.SessionToolCallStart:
			if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
				return state;
			}
			return {
				...state,
				activeTurn: {
					...state.activeTurn,
					responseParts: [
						...state.activeTurn.responseParts,
						{
							kind: ResponsePartKind.ToolCall,
							toolCall: {
								toolCallId: action.toolCallId,
								toolName: action.toolName,
								displayName: action.displayName,
								toolClientId: action.toolClientId,
								_meta: action._meta,
								status: ToolCallStatus.Streaming,
							},
						} satisfies ToolCallResponsePart,
					],
				},
			};

		case ActionType.SessionToolCallDelta:
			return updateToolCallInParts(state, action.turnId, action.toolCallId, tc => {
				if (tc.status !== ToolCallStatus.Streaming) {
					return tc;
				}
				return {
					...tc,
					partialInput: (tc.partialInput ?? '') + action.content,
					invocationMessage: action.invocationMessage ?? tc.invocationMessage,
				};
			});

		case ActionType.SessionToolCallReady:
			return refreshSummaryStatus(updateToolCallInParts(state, action.turnId, action.toolCallId, tc => {
				if (tc.status !== ToolCallStatus.Streaming && tc.status !== ToolCallStatus.Running) {
					return tc;
				}
				const base = tcBase(tc);
				if (action.confirmed) {
					return {
						status: ToolCallStatus.Running,
						...base,
						invocationMessage: action.invocationMessage,
						toolInput: action.toolInput,
						confirmed: action.confirmed,
					};
				}
				return {
					status: ToolCallStatus.PendingConfirmation,
					...base,
					invocationMessage: action.invocationMessage,
					toolInput: action.toolInput,
					confirmationTitle: action.confirmationTitle,
					edits: action.edits,
					editable: action.editable,
					...(action.options ? { options: action.options } : {}),
				};
			}));

		case ActionType.SessionToolCallConfirmed:
			return refreshSummaryStatus(updateToolCallInParts(state, action.turnId, action.toolCallId, tc => {
				if (tc.status !== ToolCallStatus.PendingConfirmation) {
					return tc;
				}
				const base = tcBase(tc);
				const selectedOption = resolveSelectedOption(tc.options, action.selectedOptionId);
				if (action.approved) {
					return {
						status: ToolCallStatus.Running,
						...base,
						invocationMessage: tc.invocationMessage,
						toolInput: action.editedToolInput ?? tc.toolInput,
						confirmed: action.confirmed,
						...(selectedOption ? { selectedOption } : {}),
					};
				}
				return {
					status: ToolCallStatus.Cancelled,
					...base,
					invocationMessage: tc.invocationMessage,
					toolInput: tc.toolInput,
					reason: action.reason,
					reasonMessage: action.reasonMessage,
					userSuggestion: action.userSuggestion,
					...(selectedOption ? { selectedOption } : {}),
				};
			}));

		case ActionType.SessionToolCallComplete:
			return refreshSummaryStatus(updateToolCallInParts(state, action.turnId, action.toolCallId, tc => {
				if (tc.status !== ToolCallStatus.Running && tc.status !== ToolCallStatus.PendingConfirmation) {
					return tc;
				}
				const base = tcBase(tc);
				const confirmed = tc.status === ToolCallStatus.Running
					? tc.confirmed
					: ToolCallConfirmationReason.NotNeeded;
				const selectedOption = tc.status === ToolCallStatus.Running
					? tc.selectedOption
					: undefined;
				if (action.requiresResultConfirmation) {
					return {
						status: ToolCallStatus.PendingResultConfirmation,
						...base,
						invocationMessage: tc.invocationMessage,
						toolInput: tc.toolInput,
						confirmed,
						...(selectedOption ? { selectedOption } : {}),
						...action.result,
					};
				}
				return {
					status: ToolCallStatus.Completed,
					...base,
					invocationMessage: tc.invocationMessage,
					toolInput: tc.toolInput,
					confirmed,
					...(selectedOption ? { selectedOption } : {}),
					...action.result,
				};
			}));

		case ActionType.SessionToolCallResultConfirmed:
			return refreshSummaryStatus(updateToolCallInParts(state, action.turnId, action.toolCallId, tc => {
				if (tc.status !== ToolCallStatus.PendingResultConfirmation) {
					return tc;
				}
				const base = tcBase(tc);
				if (action.approved) {
					return {
						status: ToolCallStatus.Completed,
						...base,
						invocationMessage: tc.invocationMessage,
						toolInput: tc.toolInput,
						confirmed: tc.confirmed,
						...(tc.selectedOption ? { selectedOption: tc.selectedOption } : {}),
						success: tc.success,
						pastTenseMessage: tc.pastTenseMessage,
						content: tc.content,
						structuredContent: tc.structuredContent,
						error: tc.error,
					};
				}
				return {
					status: ToolCallStatus.Cancelled,
					...base,
					invocationMessage: tc.invocationMessage,
					toolInput: tc.toolInput,
					reason: ToolCallCancellationReason.ResultDenied,
					...(tc.selectedOption ? { selectedOption: tc.selectedOption } : {}),
				};
			}));

		case ActionType.SessionToolCallContentChanged:
			return updateToolCallInParts(state, action.turnId, action.toolCallId, tc => {
				if (tc.status !== ToolCallStatus.Running) {
					return tc;
				}
				return {
					...tc,
					content: action.content,
				};
			});

		// ── Metadata ──────────────────────────────────────────────────────────

		case ActionType.SessionTitleChanged:
			return {
				...state,
				summary: { ...state.summary, title: action.title, modifiedAt: Date.now() },
			};

		case ActionType.SessionUsage:
			if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
				return state;
			}
			return {
				...state,
				activeTurn: { ...state.activeTurn, usage: action.usage },
			};

		case ActionType.SessionReasoning:
			return updateResponsePart(state, action.turnId, action.partId, part => {
				if (part.kind === ResponsePartKind.Reasoning) {
					return { ...part, content: part.content + action.content };
				}
				return part;
			});

		case ActionType.SessionModelChanged:
			return {
				...state,
				summary: { ...state.summary, model: action.model, modifiedAt: Date.now() },
			};

		case ActionType.SessionIsReadChanged:
			return {
				...state,
				summary: { ...state.summary, status: withStatusFlag(state.summary.status, SessionStatus.IsRead, action.isRead) },
			};

		case ActionType.SessionIsArchivedChanged:
			return {
				...state,
				summary: { ...state.summary, status: withStatusFlag(state.summary.status, SessionStatus.IsArchived, action.isArchived) },
			};

		case ActionType.SessionActivityChanged:
			return {
				...state,
				summary: { ...state.summary, activity: action.activity },
			};

		case ActionType.SessionDiffsChanged:
			return {
				...state,
				summary: { ...state.summary, diffs: action.diffs },
			};

		case ActionType.SessionConfigChanged:
			if (!state.config) {
				return state;
			}
			return {
				...state,
				config: {
					...state.config,
					values: action.replace ? { ...action.config } : { ...state.config.values, ...action.config },
				},
				summary: {
					...state.summary,
					modifiedAt: Date.now(),
				},
			};

		case ActionType.SessionMetaChanged:
			return { ...state, _meta: action._meta };

		case ActionType.SessionServerToolsChanged:
			return { ...state, serverTools: action.tools };

		case ActionType.SessionActiveClientChanged:
			return {
				...state,
				activeClient: action.activeClient ?? undefined,
			};

		case ActionType.SessionActiveClientToolsChanged:
			if (!state.activeClient) {
				return state;
			}
			return {
				...state,
				activeClient: { ...state.activeClient, tools: action.tools },
			};

		// ── Customizations ──────────────────────────────────────────────────

		case ActionType.SessionCustomizationsChanged:
			return { ...state, customizations: action.customizations };

		case ActionType.SessionCustomizationToggled: {
			const list = state.customizations;
			if (!list) {
				return state;
			}
			const idx = list.findIndex(c => c.customization.uri === action.uri);
			if (idx < 0) {
				return state;
			}
			const updated = [...list];
			updated[idx] = { ...list[idx], enabled: action.enabled };
			return { ...state, customizations: updated };
		}

		// ── Truncation ────────────────────────────────────────────────────────

		case ActionType.SessionTruncated: {
			let turns: typeof state.turns;
			if (action.turnId === undefined) {
				turns = [];
			} else {
				const idx = state.turns.findIndex(t => t.id === action.turnId);
				if (idx < 0) {
					return state;
				}
				turns = state.turns.slice(0, idx + 1);
			}
			const next: SessionState = {
				...state,
				turns,
				activeTurn: undefined,
				summary: { ...state.summary, modifiedAt: Date.now() },
			};
			delete next.inputRequests;
			return {
				...next,
				summary: { ...next.summary, status: summaryStatus(next) },
			};
		}

		// ── Session Input Requests ─────────────────────────────────────────────

		case ActionType.SessionInputRequested:
			return upsertInputRequest(state, action.request);

		case ActionType.SessionInputAnswerChanged: {
			const existing = state.inputRequests;
			const idx = existing?.findIndex(request => request.id === action.requestId) ?? -1;
			if (!existing || idx < 0) {
				return state;
			}
			const request = existing[idx];
			const answers = { ...(request.answers ?? {}) };
			if (action.answer === undefined) {
				delete answers[action.questionId];
			} else {
				answers[action.questionId] = action.answer;
			}
			const updated = [...existing];
			updated[idx] = {
				...request,
				answers: Object.keys(answers).length > 0 ? answers : undefined,
			};
			return {
				...state,
				inputRequests: updated,
				summary: { ...state.summary, modifiedAt: Date.now() },
			};
		}

		case ActionType.SessionInputCompleted: {
			const existing = state.inputRequests;
			if (!existing?.some(request => request.id === action.requestId)) {
				return state;
			}
			const inputRequests = existing.filter(request => request.id !== action.requestId);
			const next: SessionState = {
				...state,
			};
			if (inputRequests.length > 0) {
				next.inputRequests = inputRequests;
			} else {
				delete next.inputRequests;
			}
			return {
				...next,
				summary: { ...next.summary, status: summaryStatus(next), modifiedAt: Date.now() },
			};
		}

		// ── Pending Messages ──────────────────────────────────────────────────

		case ActionType.SessionPendingMessageSet: {
			const entry: PendingMessage = { id: action.id, userMessage: action.userMessage };
			if (action.kind === PendingMessageKind.Steering) {
				return { ...state, steeringMessage: entry };
			}
			const existing = state.queuedMessages ?? [];
			const idx = existing.findIndex(m => m.id === action.id);
			if (idx >= 0) {
				const updated = [...existing];
				updated[idx] = entry;
				return { ...state, queuedMessages: updated };
			}
			return { ...state, queuedMessages: [...existing, entry] };
		}

		case ActionType.SessionPendingMessageRemoved: {
			if (action.kind === PendingMessageKind.Steering) {
				if (!state.steeringMessage || state.steeringMessage.id !== action.id) {
					return state;
				}
				return { ...state, steeringMessage: undefined };
			}
			const existing = state.queuedMessages;
			if (!existing) {
				return state;
			}
			const filtered = existing.filter(m => m.id !== action.id);
			return filtered.length === existing.length
				? state
				: { ...state, queuedMessages: filtered.length > 0 ? filtered : undefined };
		}

		case ActionType.SessionQueuedMessagesReordered: {
			const existing = state.queuedMessages;
			if (!existing) {
				return state;
			}
			const byId = new Map(existing.map(m => [m.id, m]));
			const ordered = new Set<string>();
			const reordered = action.order
				.filter(id => {
					if (byId.has(id) && !ordered.has(id)) {
						ordered.add(id);
						return true;
					}
					return false;
				})
				.map(id => byId.get(id)!);
			// Append any messages not mentioned in order, preserving original order
			for (const m of existing) {
				if (!ordered.has(m.id)) {
					reordered.push(m);
				}
			}
			return { ...state, queuedMessages: reordered };
		}

		default:
			softAssertNever(action, log);
			return state;
	}
}

// ─── Terminal Reducer ────────────────────────────────────────────────────────

/**
 * Pure reducer for terminal state. Handles all {@link TerminalAction} variants.
 */
export function terminalReducer(state: TerminalState, action: TerminalAction, log?: (msg: string) => void): TerminalState {
	switch (action.type) {
		case ActionType.TerminalData: {
			const content = [...state.content];
			const tail = content.length > 0 ? content[content.length - 1] : undefined;
			if (tail && tail.type === 'command' && !tail.isComplete) {
				content[content.length - 1] = { ...tail, output: tail.output + action.data };
			} else if (tail && tail.type === 'unclassified') {
				content[content.length - 1] = { ...tail, value: tail.value + action.data };
			} else {
				content.push({ type: 'unclassified', value: action.data });
			}
			return { ...state, content };
		}

		case ActionType.TerminalInput:
			// Side-effect-only: the server forwards to the pty.
			// No state change in the reducer.
			return state;

		case ActionType.TerminalResized:
			return { ...state, cols: action.cols, rows: action.rows };

		case ActionType.TerminalClaimed:
			return { ...state, claim: action.claim };

		case ActionType.TerminalTitleChanged:
			return { ...state, title: action.title };

		case ActionType.TerminalCwdChanged:
			return { ...state, cwd: action.cwd };

		case ActionType.TerminalExited:
			return { ...state, exitCode: action.exitCode };

		case ActionType.TerminalCleared:
			return { ...state, content: [] };

		case ActionType.TerminalCommandDetectionAvailable:
			return { ...state, supportsCommandDetection: true };

		case ActionType.TerminalCommandExecuted: {
			const part: TerminalContentPart = {
				type: 'command',
				commandId: action.commandId,
				commandLine: action.commandLine,
				output: '',
				timestamp: action.timestamp,
				isComplete: false,
			};
			return {
				...state,
				content: [...state.content, part],
				supportsCommandDetection: true,
			};
		}

		case ActionType.TerminalCommandFinished: {
			const content = state.content.map(p => {
				if (p.type === 'command' && p.commandId === action.commandId) {
					return {
						...p,
						isComplete: true as const,
						exitCode: action.exitCode,
						durationMs: action.durationMs,
					};
				}
				return p;
			});
			return { ...state, content };
		}

		default:
			softAssertNever(action, log);
			return state;
	}
}

// ─── Dispatch Validation ─────────────────────────────────────────────────────

/**
 * Type guard that checks whether an action may be dispatched by a client.
 *
 * Servers SHOULD call this to validate incoming `dispatchAction` requests
 * and reject any action the client is not allowed to originate.
 */
export function isClientDispatchable(action: RootAction | SessionAction | TerminalAction): action is ClientRootAction | ClientSessionAction | ClientTerminalAction {
	return IS_CLIENT_DISPATCHABLE[action.type];
}