Address code review feedback for Tasks panel IPC

- Remove unused `scope` feature from IPC protocol (YAGNI)
- Remove redundant array spreads in TasksPanel
- Make TaskDetails extend TaskActions to reduce duplication
- Remove handler fallback in TasksPanel (keep requests/commands separate)
- Add notification subscription support to useIpc hook
- Add tests for onNotification feature
- Remove redundant individual exports from tasks/api.ts (export as group only)

Author: EhabY

packages/shared/src/ipc/protocol.ts

@@ -10,23 +10,20 @@
 /** Request definition: params P, response R */
 export interface RequestDef<P = void, R = void> {
 	readonly method: string;
-	readonly scope?: string;
 	/** @internal Phantom types for inference - not present at runtime */
 	readonly _types?: { params: P; response: R };
 }
 
 /** Command definition: params P, no response */
 export interface CommandDef<P = void> {
 	readonly method: string;
-	readonly scope?: string;
 	/** @internal Phantom type for inference - not present at runtime */
 	readonly _types?: { params: P };
 }
 
 /** Notification definition: data D (extension to webview) */
 export interface NotificationDef<D = void> {
 	readonly method: string;
-	readonly scope?: string;
 	/** @internal Phantom type for inference - not present at runtime */
 	readonly _types?: { data: D };
 }
@@ -36,25 +33,20 @@ export interface NotificationDef<D = void> {
 /** Define a request with typed params and response */
 export function defineRequest<P = void, R = void>(
 	method: string,
-	scope?: string,
 ): RequestDef<P, R> {
-	return { method, scope } as RequestDef<P, R>;
+	return { method } as RequestDef<P, R>;
 }
 
 /** Define a fire-and-forget command */
-export function defineCommand<P = void>(
-	method: string,
-	scope?: string,
-): CommandDef<P> {
-	return { method, scope } as CommandDef<P>;
+export function defineCommand<P = void>(method: string): CommandDef<P> {
+	return { method } as CommandDef<P>;
 }
 
 /** Define a push notification (extension to webview) */
 export function defineNotification<D = void>(
 	method: string,
-	scope?: string,
 ): NotificationDef<D> {
-	return { method, scope } as NotificationDef<D>;
+	return { method } as NotificationDef<D>;
 }
 
 // --- Wire format ---
@@ -63,7 +55,6 @@ export function defineNotification<D = void>(
 export interface IpcRequest<P = unknown> {
 	readonly requestId: string;
 	readonly method: string;
-	readonly scope?: string;
 	readonly params?: P;
 }
 

packages/shared/src/tasks/api.ts

@@ -17,20 +17,18 @@ import {
 
 import type { Task, TaskDetails, TaskLogEntry, TaskTemplate } from "./types";
 
-// --- Requests ---
-
 export interface InitResponse {
-	tasks: Task[];
-	templates: TaskTemplate[];
+	tasks: readonly Task[];
+	templates: readonly TaskTemplate[];
 	baseUrl: string;
 	tasksSupported: boolean;
 }
 
-export const init = defineRequest<void, InitResponse>("init");
-export const getTasks = defineRequest<void, Task[]>("getTasks");
-export const getTemplates = defineRequest<void, TaskTemplate[]>("getTemplates");
-export const getTask = defineRequest<{ taskId: string }, Task>("getTask");
-export const getTaskDetails = defineRequest<{ taskId: string }, TaskDetails>(
+const init = defineRequest<void, InitResponse>("init");
+const getTasks = defineRequest<void, Task[]>("getTasks");
+const getTemplates = defineRequest<void, TaskTemplate[]>("getTemplates");
+const getTask = defineRequest<{ taskId: string }, Task>("getTask");
+const getTaskDetails = defineRequest<{ taskId: string }, TaskDetails>(
 	"getTaskDetails",
 );
 
@@ -39,31 +37,25 @@ export interface CreateTaskParams {
 	prompt: string;
 	presetId?: string;
 }
-export const createTask = defineRequest<CreateTaskParams, Task>("createTask");
-
-export const deleteTask = defineRequest<{ taskId: string }, void>("deleteTask");
-export const pauseTask = defineRequest<{ taskId: string }, void>("pauseTask");
-export const resumeTask = defineRequest<{ taskId: string }, void>("resumeTask");
+const createTask = defineRequest<CreateTaskParams, Task>("createTask");
 
-// --- Commands ---
+const deleteTask = defineRequest<{ taskId: string }, void>("deleteTask");
+const pauseTask = defineRequest<{ taskId: string }, void>("pauseTask");
+const resumeTask = defineRequest<{ taskId: string }, void>("resumeTask");
 
-export const viewInCoder = defineCommand<{ taskId: string }>("viewInCoder");
-export const viewLogs = defineCommand<{ taskId: string }>("viewLogs");
-export const downloadLogs = defineCommand<{ taskId: string }>("downloadLogs");
-export const sendTaskMessage = defineCommand<{
+const viewInCoder = defineCommand<{ taskId: string }>("viewInCoder");
+const viewLogs = defineCommand<{ taskId: string }>("viewLogs");
+const downloadLogs = defineCommand<{ taskId: string }>("downloadLogs");
+const sendTaskMessage = defineCommand<{
 	taskId: string;
 	message: string;
 }>("sendTaskMessage");
 
-// --- Notifications ---
-
-export const taskUpdated = defineNotification<Task>("taskUpdated");
-export const tasksUpdated = defineNotification<Task[]>("tasksUpdated");
-export const logsAppend = defineNotification<TaskLogEntry[]>("logsAppend");
-export const refresh = defineNotification<void>("refresh");
-export const showCreateForm = defineNotification<void>("showCreateForm");
-
-// --- Grouped export ---
+const taskUpdated = defineNotification<Task>("taskUpdated");
+const tasksUpdated = defineNotification<Task[]>("tasksUpdated");
+const logsAppend = defineNotification<TaskLogEntry[]>("logsAppend");
+const refresh = defineNotification<void>("refresh");
+const showCreateForm = defineNotification<void>("showCreateForm");
 
 export const TasksApi = {
 	// Requests

packages/shared/src/tasks/types.ts

@@ -5,19 +5,10 @@ import type {
 	TaskState,
 	TaskStatus,
 	Template,
-	WorkspaceStatus,
 } from "coder/site/src/api/typesGenerated";
 
 // Re-export SDK types for convenience
-export type {
-	Preset,
-	Task,
-	TaskLogEntry,
-	TaskState,
-	TaskStatus,
-	Template,
-	WorkspaceStatus,
-};
+export type { Preset, Task, TaskLogEntry, TaskState, TaskStatus, Template };
 
 /**
  * Combined template and preset information for the create task form.
@@ -44,78 +35,57 @@ export type LogsStatus = "ok" | "not_available" | "error";
 /**
  * Full details for a selected task, including logs and action availability.
  */
-export interface TaskDetails {
+export interface TaskDetails extends TaskActions {
 	task: Task;
 	logs: TaskLogEntry[];
 	logsStatus: LogsStatus;
-	canResume: boolean;
-	canPause: boolean;
 }
 
 export interface TaskActions {
 	canPause: boolean;
+	pauseDisabled: boolean;
 	canResume: boolean;
 }
 
-const RESUMABLE_STATUSES: readonly WorkspaceStatus[] = [
-	"stopped",
-	"failed",
-	"canceled",
+const PAUSABLE_STATUSES: readonly TaskStatus[] = [
+	"active",
+	"initializing",
+	"pending",
+	"error",
+	"unknown",
 ];
 
-const PAUSED_STATUSES: readonly WorkspaceStatus[] = [
-	"stopped",
-	"stopping",
-	"canceled",
+const PAUSE_DISABLED_STATUSES: readonly TaskStatus[] = [
+	"pending",
+	"initializing",
 ];
 
-const INITIALIZING_STATUSES: readonly WorkspaceStatus[] = [
-	"starting",
-	"pending",
+const RESUMABLE_STATUSES: readonly TaskStatus[] = [
+	"paused",
+	"error",
+	"unknown",
 ];
 
 export function getTaskActions(task: Task): TaskActions {
 	const hasWorkspace = task.workspace_id !== null;
-	const status = task.workspace_status;
+	const status = task.status;
 	return {
-		canPause: hasWorkspace && status === "running",
-		canResume: hasWorkspace && !!status && RESUMABLE_STATUSES.includes(status),
+		canPause: hasWorkspace && PAUSABLE_STATUSES.includes(status),
+		pauseDisabled: PAUSE_DISABLED_STATUSES.includes(status),
+		canResume: hasWorkspace && RESUMABLE_STATUSES.includes(status),
 	};
 }
 
-/** UI state derived from task status, state, and workspace status */
-export type TaskUIState =
-	| "working"
-	| "idle"
-	| "complete"
-	| "error"
-	| "paused"
-	| "initializing";
-
-/** Compute the UI state from a Task object */
-export function getTaskUIState(task: Task): TaskUIState {
-	const taskState = task.current_state?.state;
-	const workspaceStatus = task.workspace_status;
-
-	if (task.status === "error" || taskState === "failed") {
-		return "error";
-	}
-
-	if (workspaceStatus && PAUSED_STATUSES.includes(workspaceStatus)) {
-		return "paused";
-	}
-
-	if (workspaceStatus && INITIALIZING_STATUSES.includes(workspaceStatus)) {
-		return "initializing";
-	}
-
-	if (task.status === "active" && workspaceStatus === "running" && taskState) {
-		return taskState;
-	}
-
-	if (taskState === "complete") {
-		return "complete";
-	}
-
-	return "idle";
+/**
+ * Task statuses where logs won't change (stable/terminal states).
+ * "complete" is a TaskState (sub-state of active), checked separately.
+ */
+const STABLE_STATUSES: readonly TaskStatus[] = ["error", "paused"];
+
+/** Whether a task is in a stable state where its logs won't change. */
+export function isStableTask(task: Task): boolean {
+	return (
+		STABLE_STATUSES.includes(task.status) ||
+		task.current_state?.state === "complete"
+	);
 }

packages/tasks/src/hooks/useTasksApi.ts

@@ -9,44 +9,32 @@
  * ```
  */
 
-import {
-	createTask as createTaskDef,
-	deleteTask as deleteTaskDef,
-	downloadLogs as downloadLogsDef,
-	getTask as getTaskDef,
-	getTaskDetails as getTaskDetailsDef,
-	getTasks as getTasksDef,
-	getTemplates as getTemplatesDef,
-	init as initDef,
-	pauseTask as pauseTaskDef,
-	resumeTask as resumeTaskDef,
-	sendTaskMessage as sendTaskMessageDef,
-	viewInCoder as viewInCoderDef,
-	viewLogs as viewLogsDef,
-	type CreateTaskParams,
-} from "@repo/shared";
+import { TasksApi, type CreateTaskParams } from "@repo/shared";
 import { useIpc } from "@repo/webview-shared/react";
 
 export function useTasksApi() {
 	const { request, command } = useIpc();
 
 	return {
 		// Requests
-		init: () => request(initDef),
-		getTasks: () => request(getTasksDef),
-		getTemplates: () => request(getTemplatesDef),
-		getTask: (taskId: string) => request(getTaskDef, { taskId }),
-		getTaskDetails: (taskId: string) => request(getTaskDetailsDef, { taskId }),
-		createTask: (params: CreateTaskParams) => request(createTaskDef, params),
-		deleteTask: (taskId: string) => request(deleteTaskDef, { taskId }),
-		pauseTask: (taskId: string) => request(pauseTaskDef, { taskId }),
-		resumeTask: (taskId: string) => request(resumeTaskDef, { taskId }),
+		init: () => request(TasksApi.init),
+		getTasks: () => request(TasksApi.getTasks),
+		getTemplates: () => request(TasksApi.getTemplates),
+		getTask: (taskId: string) => request(TasksApi.getTask, { taskId }),
+		getTaskDetails: (taskId: string) =>
+			request(TasksApi.getTaskDetails, { taskId }),
+		createTask: (params: CreateTaskParams) =>
+			request(TasksApi.createTask, params),
+		deleteTask: (taskId: string) => request(TasksApi.deleteTask, { taskId }),
+		pauseTask: (taskId: string) => request(TasksApi.pauseTask, { taskId }),
+		resumeTask: (taskId: string) => request(TasksApi.resumeTask, { taskId }),
 
 		// Commands
-		viewInCoder: (taskId: string) => command(viewInCoderDef, { taskId }),
-		viewLogs: (taskId: string) => command(viewLogsDef, { taskId }),
-		downloadLogs: (taskId: string) => command(downloadLogsDef, { taskId }),
+		viewInCoder: (taskId: string) => command(TasksApi.viewInCoder, { taskId }),
+		viewLogs: (taskId: string) => command(TasksApi.viewLogs, { taskId }),
+		downloadLogs: (taskId: string) =>
+			command(TasksApi.downloadLogs, { taskId }),
 		sendTaskMessage: (taskId: string, message: string) =>
-			command(sendTaskMessageDef, { taskId, message }),
+			command(TasksApi.sendTaskMessage, { taskId, message }),
 	};
 }

packages/webview-shared/src/index.ts

@@ -3,7 +3,6 @@ export interface WebviewMessage {
 	method: string;
 	params?: unknown;
 	requestId?: string;
-	scope?: string;
 }
 
 // VS Code state API