Wire project folder badge to toggle inline subtasks

The folder/project badge on task cards called applyProjectSubtaskFilter(),
a placeholder left from the v4 view-system removal (commit 96519c5) that
always showed "Project subtask filtering not available" — a dead action with
no setting to enable it, while its tooltip still advertised "click to filter
subtasks".

Wire the badge to toggle the inline subtask list instead, sharing expansion
state with the chevron via expandedProjectsService so the two stay in sync.
The subtask render is moved out from behind the showExpandableSubtasks gate
so the folder works even when the chevron is disabled. Fix the misleading
tooltip and remove the dead applyProjectSubtaskFilter / createProjectClickHandler
/ TaskListView.filterProjectSubtasks paths.

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

Author: abbiefalls

src/bases/TaskListView.ts

@@ -2515,9 +2515,6 @@ export class TaskListView extends BasesViewBase {
 					event
 				);
 				return;
-			case "filter-project-subtasks":
-				await this.filterProjectSubtasks(task);
-				return;
 			case "toggle-subtasks":
 				await this.toggleSubtasks(task, target);
 				return;
@@ -2753,19 +2750,6 @@ export class TaskListView extends BasesViewBase {
 		}
 	}
 
-	private async filterProjectSubtasks(task: TaskInfo): Promise<void> {
-		try {
-			await this.plugin.applyProjectSubtaskFilter(task);
-		} catch (error) {
-			tasknotesLogger.error("[TaskNotes][TaskListView] Failed to filter project subtasks", {
-				category: "persistence",
-				operation: "filter-project-subtasks",
-				error: error,
-			});
-			new Notice("Failed to filter project subtasks");
-		}
-	}
-
 	private async toggleSubtasks(task: TaskInfo, target: HTMLElement): Promise<void> {
 		try {
 			if (!this.plugin.expandedProjectsService) {

src/i18n/resources/en.ts

@@ -3273,7 +3273,7 @@ export const en: TranslationTree = {
 			reminderTooltipOne: "1 reminder set (click to manage)",
 			reminderTooltipMany: "{count} reminders set (click to manage)",
 			detailsTooltip: "Task has details",
-			projectTooltip: "This task is used as a project (click to filter subtasks)",
+			projectTooltip: "This task is used as a project (click to show/hide subtasks)",
 			expandSubtasks: "Expand subtasks",
 			collapseSubtasks: "Collapse subtasks",
 			dueToday: "{label}: Today",

src/main.ts

@@ -1267,30 +1267,6 @@ export default class TaskNotesPlugin extends Plugin {
 		await this.taskActionCoordinator.rolloverOverdueScheduledTasks();
 	}
 
-	/**
-	 * Apply a filter to show subtasks of a project
-	 */
-	async applyProjectSubtaskFilter(projectTask: TaskInfo): Promise<void> {
-		try {
-			const file = this.app.vault.getAbstractFileByPath(projectTask.path);
-			if (!file) {
-				new Notice("Project file not found");
-				return;
-			}
-
-			// Note: This feature was part of the old view system (deprecated in v4)
-			// TODO: Re-implement for Bases views if needed
-			new Notice("Project subtask filtering not available");
-		} catch (error) {
-			tasknotesLogger.error("Error applying project subtask filter:", {
-				category: "persistence",
-				operation: "applying-project-subtask-filter",
-				error: error,
-			});
-			new Notice("Failed to apply project filter");
-		}
-	}
-
 	/**
 	 * Starts a time tracking session for a task
 	 */

src/ui/taskCardActions.ts

@@ -184,24 +184,3 @@ export function createReminderClickHandler(task: TaskInfo, plugin: TaskNotesPlug
 	};
 }
 
-/**
- * Creates a click handler for project indicators.
- */
-export function createProjectClickHandler(task: TaskInfo, plugin: TaskNotesPlugin): () => void {
-	return () => {
-		void (async () => {
-			const logger = getTaskCardActionLogger(plugin);
-			try {
-				await plugin.applyProjectSubtaskFilter(task);
-			} catch (error) {
-				logger.error("Error filtering project subtasks", {
-					category: "internal",
-					operation: "filter-project-subtasks",
-					details: { taskPath: task.path },
-					error,
-				});
-				new Notice("Failed to filter project subtasks");
-			}
-		})();
-	};
-}

src/ui/taskCardSecondaryBadges.ts

@@ -3,7 +3,6 @@ import type TaskNotesPlugin from "../main";
 import type { TaskInfo } from "../types";
 import { createTaskNotesLogger } from "../utils/tasknotesLogger";
 import {
-	createProjectClickHandler,
 	createRecurrenceClickHandler,
 	createReminderClickHandler,
 } from "./taskCardActions";
@@ -153,6 +152,51 @@ function createChevronClickHandler(
 	};
 }
 
+/**
+ * Toggles the inline subtask list for a project task card. Used by the folder
+ * (project) badge so it works whether or not the expand chevron is rendered,
+ * keeping the chevron visual in sync when it is present. Shares expansion state
+ * with the chevron via expandedProjectsService, so the two never diverge.
+ */
+function createProjectSubtasksToggleHandler(
+	task: TaskInfo,
+	plugin: TaskNotesPlugin,
+	card: HTMLElement,
+	handlers: TaskCardSecondaryBadgeHandlers
+): () => void {
+	return () => {
+		void (async () => {
+			const logger = getTaskCardBadgeLogger(plugin);
+			try {
+				if (!plugin.expandedProjectsService) {
+					new Notice("Service not available. Please try reloading the plugin.");
+					return;
+				}
+
+				const newExpanded = plugin.expandedProjectsService.toggle(
+					task.path,
+					shouldExpandSubtasksByDefault(plugin)
+				);
+
+				const chevron = card.querySelector<HTMLElement>(".task-card__chevron");
+				if (chevron) {
+					updateChevronElement(chevron, plugin, newExpanded);
+				}
+
+				await handlers.toggleSubtasks(card, task, newExpanded);
+			} catch (error) {
+				logger.error("Error toggling project subtasks", {
+					category: "internal",
+					operation: "toggle-project-subtasks",
+					details: { taskPath: task.path },
+					error,
+				});
+				new Notice("Failed to toggle subtasks");
+			}
+		})();
+	};
+}
+
 function createBlockingToggleClickHandler(
 	task: TaskInfo,
 	card: HTMLElement,
@@ -217,27 +261,31 @@ function renderProjectBadges(
 		return;
 	}
 
+	const isExpanded = isTaskCardSubtasksExpanded(task, plugin);
+
+	// The folder badge toggles the inline subtask list. It is always rendered for
+	// a project and works on its own, so subtasks remain reachable from the card
+	// even when the expand chevron is disabled.
 	createBadgeIndicator({
 		container: badgesContainer,
 		className: "task-card__project-indicator",
 		icon: "folder",
 		tooltip: tTaskCard(plugin, "projectTooltip"),
-		onClick: createProjectClickHandler(task, plugin),
+		onClick: createProjectSubtasksToggleHandler(task, plugin, card, handlers),
 	});
 
-	if (!plugin.settings?.showExpandableSubtasks) {
-		return;
+	if (plugin.settings?.showExpandableSubtasks) {
+		createBadgeIndicator({
+			container: badgesContainer,
+			className: `task-card__chevron${isExpanded ? " task-card__chevron--expanded" : ""}`,
+			icon: "chevron-right",
+			tooltip: getChevronTooltip(plugin, isExpanded),
+			onClick: createChevronClickHandler(task, plugin, card, handlers),
+		});
 	}
 
-	const isExpanded = isTaskCardSubtasksExpanded(task, plugin);
-	createBadgeIndicator({
-		container: badgesContainer,
-		className: `task-card__chevron${isExpanded ? " task-card__chevron--expanded" : ""}`,
-		icon: "chevron-right",
-		tooltip: getChevronTooltip(plugin, isExpanded),
-		onClick: createChevronClickHandler(task, plugin, card, handlers),
-	});
-
+	// Render the subtask list immediately when expanded, regardless of whether the
+	// chevron is shown — otherwise a folder-driven expansion would not re-render.
 	if (isExpanded) {
 		handlers.toggleSubtasks(card, task, true).catch((error: unknown) => {
 			getTaskCardBadgeLogger(plugin).error("Error showing initial subtasks", {
@@ -346,14 +394,15 @@ function updateProjectBadges(options: UpdateTaskCardSecondaryBadgesOptions): voi
 				className: "task-card__project-indicator",
 				icon: "folder",
 				tooltip: tTaskCard(plugin, "projectTooltip"),
-				onClick: createProjectClickHandler(task, plugin),
+				onClick: createProjectSubtasksToggleHandler(task, plugin, card, handlers),
 			});
 
 			const showChevron = isProject && plugin.settings?.showExpandableSubtasks;
 			const existingChevron = card.querySelector<HTMLElement>(".task-card__chevron");
+			const isExpanded = isProject && isTaskCardSubtasksExpanded(task, plugin);
 
+			// Keep the chevron in sync with the setting (create / update / remove).
 			if (showChevron && !existingChevron) {
-				const isExpanded = isTaskCardSubtasksExpanded(task, plugin);
 				createBadgeIndicator({
 					container:
 						card.querySelector<HTMLElement>(".task-card__badges") ?? mainRow ?? card,
@@ -362,35 +411,24 @@ function updateProjectBadges(options: UpdateTaskCardSecondaryBadgesOptions): voi
 					tooltip: getChevronTooltip(plugin, isExpanded),
 					onClick: createChevronClickHandler(task, plugin, card, handlers),
 				});
-
-				if (isExpanded) {
-					handlers.toggleSubtasks(card, task, true).catch((error: unknown) => {
-						logger.error("Error showing initial subtasks in update", {
-							category: "internal",
-							operation: "show-initial-subtasks-update",
-							details: { taskPath: task.path },
-							error,
-						});
-					});
-				}
 			} else if (showChevron && existingChevron) {
-				const isExpanded = isTaskCardSubtasksExpanded(task, plugin);
 				updateChevronElement(existingChevron, plugin, isExpanded);
-
-				if (isExpanded) {
-					handlers.toggleSubtasks(card, task, true).catch((error: unknown) => {
-						logger.error("Error refreshing default-expanded subtasks", {
-							category: "internal",
-							operation: "refresh-default-expanded-subtasks",
-							details: { taskPath: task.path },
-							error,
-						});
-					});
-				} else {
-					removeRelationshipContainer(card, ".task-card__subtasks");
-				}
 			} else if (!showChevron && existingChevron) {
 				existingChevron.remove();
+			}
+
+			// Sync the inline subtask list independently of the chevron, so the
+			// folder badge can drive expansion even when the chevron is disabled.
+			if (isExpanded) {
+				handlers.toggleSubtasks(card, task, true).catch((error: unknown) => {
+					logger.error("Error showing subtasks in update", {
+						category: "internal",
+						operation: "show-subtasks-update",
+						details: { taskPath: task.path },
+						error,
+					});
+				});
+			} else {
 				removeRelationshipContainer(card, ".task-card__subtasks");
 			}
 		})

tests/unit/ui/taskCardActions.test.ts

@@ -1,7 +1,6 @@
 import { Notice } from "obsidian";
 import {
 	createPriorityClickHandler,
-	createProjectClickHandler,
 	createRecurrenceClickHandler,
 	createReminderClickHandler,
 	createStatusCycleHandler,
@@ -67,7 +66,6 @@ function createPlugin(overrides: Partial<TaskNotesPlugin> = {}): TaskNotesPlugin
 			...updatedTask,
 			status: "done",
 		})),
-		applyProjectSubtaskFilter: jest.fn(async () => undefined),
 		...overrides,
 	} as unknown as TaskNotesPlugin;
 }
@@ -193,14 +191,4 @@ describe("taskCardActions", () => {
 		expect(modalInstance.open).toHaveBeenCalled();
 		expect(plugin.updateTaskProperty).toHaveBeenCalledWith(task, "reminders", reminders);
 	});
-
-	it("wires project indicators to the project-subtask filter", async () => {
-		const plugin = createPlugin();
-		const handler = createProjectClickHandler(task, plugin);
-
-		handler();
-		await flushAsyncHandlers();
-
-		expect(plugin.applyProjectSubtaskFilter).toHaveBeenCalledWith(task);
-	});
 });

tests/unit/ui/taskCardSecondaryBadges.test.ts

@@ -129,6 +129,66 @@ describe("taskCardSecondaryBadges", () => {
 		expect(handlers.toggleSubtasks).toHaveBeenCalledWith(card, task, true);
 	});
 
+	it("toggles the inline subtask list when the project folder badge is clicked", async () => {
+		const plugin = createPlugin();
+		(plugin.projectSubtasksService.isTaskUsedAsProjectSync as jest.Mock).mockReturnValue(true);
+		(plugin.expandedProjectsService?.isExpanded as jest.Mock).mockReturnValue(false);
+		(plugin.expandedProjectsService?.toggle as jest.Mock).mockReturnValue(true);
+		const handlers = createHandlers();
+		const { card, badgesContainer } = createCard();
+		const task = createTask();
+
+		renderTaskCardSecondaryBadges({
+			card,
+			badgesContainer,
+			task,
+			plugin,
+			hasDetails: false,
+			propertyOptions: {},
+			handlers,
+		});
+
+		const folder = card.querySelector<HTMLElement>(".task-card__project-indicator");
+		expect(folder).not.toBeNull();
+
+		folder?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(plugin.expandedProjectsService?.toggle).toHaveBeenCalledWith(task.path, false);
+		expect(handlers.toggleSubtasks).toHaveBeenCalledWith(card, task, true);
+	});
+
+	it("renders subtasks for an expanded project even when the chevron is disabled", () => {
+		const plugin = createPlugin({
+			settings: {
+				showExpandableSubtasks: false,
+				expandSubtasksByDefault: false,
+				enableDebugLogging: false,
+			},
+		} as unknown as Partial<TaskNotesPlugin>);
+		(plugin.projectSubtasksService.isTaskUsedAsProjectSync as jest.Mock).mockReturnValue(true);
+		(plugin.expandedProjectsService?.isExpanded as jest.Mock).mockReturnValue(true);
+		const handlers = createHandlers();
+		const { card, badgesContainer } = createCard();
+		const task = createTask();
+
+		renderTaskCardSecondaryBadges({
+			card,
+			badgesContainer,
+			task,
+			plugin,
+			hasDetails: false,
+			propertyOptions: {},
+			handlers,
+		});
+
+		// Folder badge is present, chevron is not, but subtasks still render.
+		expect(card.querySelector(".task-card__project-indicator")).not.toBeNull();
+		expect(card.querySelector(".task-card__chevron")).toBeNull();
+		expect(handlers.toggleSubtasks).toHaveBeenCalledWith(card, task, true);
+	});
+
 	it("keeps secondary badges omitted when the option is disabled", () => {
 		const plugin = createPlugin();
 		const handlers = createHandlers();