agkan 3.15.0 → 3.15.2

package/dist/cli/commands/task/list.js

@@ -16,10 +16,68 @@ const validators_1 = require("../../utils/validators");
 const tag_resolver_1 = require("../../utils/tag-resolver");
 const format_1 = require("../../../utils/format");
 const output_formatter_1 = require("../../utils/output-formatter");
+const errors_1 = require("../../../errors");
 /**
- * Recursive function to display tasks in tree structure.
+ * Map the common set of task fields (shared by tree/list/dep-tree node builders)
+ * plus resolved tags and metadata for a task.
  */
-function printTreeTaskDetails(task, childPrefix, allTasksMetadata) {
+function mapTaskFields(task, allTaskTags, allTasksMetadata) {
+    const tags = allTaskTags.get(task.id);
+    const metadata = allTasksMetadata.get(task.id);
+    return {
+        id: task.id,
+        title: task.title,
+        body: task.body,
+        author: task.author,
+        assignees: task.assignees,
+        status: task.status,
+        priority: task.priority,
+        parent_id: task.parent_id,
+        created_at: task.created_at,
+        updated_at: task.updated_at,
+        tags: tags ? tags.map((tag) => ({ id: tag.id, name: tag.name })) : [],
+        metadata: metadata ? metadata.map((m) => ({ key: m.key, value: m.value })) : [],
+    };
+}
+/**
+ * Build a Map of task id -> task (including archived, unfiltered) and a Map of
+ * parent id -> non-archived children, both from a single bulk query. This
+ * replaces the N+1 getChildTasks()/getTask() calls previously made per node.
+ *
+ * getChildTasks()/getTask() ignore the list command's status/tag/priority filters
+ * and getChildTasks() always excludes archived tasks, so the maps here are built
+ * from the full (unfiltered) task set to preserve that exact behavior.
+ */
+function buildTaskMaps(taskService) {
+    const allTasks = taskService.listTasks({ includeArchived: true }, 'created_at', 'asc');
+    const taskById = new Map();
+    const childrenByParentId = new Map();
+    for (const task of allTasks) {
+        taskById.set(task.id, task);
+        if (task.is_archived || task.parent_id == null) {
+            continue;
+        }
+        const existing = childrenByParentId.get(task.parent_id);
+        if (existing) {
+            existing.push(task);
+        }
+        else {
+            childrenByParentId.set(task.parent_id, [task]);
+        }
+    }
+    return { taskById, childrenByParentId };
+}
+/**
+ * Print a single tree/dep-tree node line (connector, id, title, status),
+ * followed by its priority and metadata lines.
+ */
+function printTreeNode(task, allTasksMetadata, prefix, isLast, relationshipLabel) {
+    const statusColor = (0, format_1.getStatusColor)(task.status);
+    const connector = isLast ? '└── ' : '├── ';
+    const labelStr = relationshipLabel ? `${chalk_1.default.gray(relationshipLabel)} ` : '';
+    console.log(`${prefix}${connector}${labelStr}${chalk_1.default.bold.cyan(`[${task.id}]`)} ${chalk_1.default.bold(task.title)} ` +
+        `${chalk_1.default[statusColor](`(${task.status})`)}`);
+    const childPrefix = prefix + (isLast ? '    ' : '│   ');
     if (task.priority) {
         console.log(`${childPrefix}${formatPriority(task.priority)}`);
     }
@@ -29,50 +87,65 @@ function printTreeTaskDetails(task, childPrefix, allTasksMetadata) {
         console.log(`${childPrefix}${chalk_1.default.bold('Metadata:')} ${metadataStrings.join(', ')}`);
     }
 }
-function displayTaskTree(taskService, task, prefix, isLast, allTasksMetadata) {
-    const statusColor = (0, format_1.getStatusColor)(task.status);
-    const connector = isLast ? '└── ' : '├── ';
-    console.log(`${prefix}${connector}${chalk_1.default.bold.cyan(`[${task.id}]`)} ${chalk_1.default.bold(task.title)} ` +
-        `${chalk_1.default[statusColor](`(${task.status})`)}`);
-    const childPrefix = prefix + (isLast ? '    ' : '│   ');
-    printTreeTaskDetails(task, childPrefix, allTasksMetadata);
-    const children = taskService.getChildTasks(task.id);
+/**
+ * Recursive function to display tasks in tree structure.
+ */
+function displayTaskTree(task, childrenByParentId, prefix, isLast, allTasksMetadata) {
+    printTreeNode(task, allTasksMetadata, prefix, isLast);
+    const children = childrenByParentId.get(task.id) || [];
     if (children.length > 0) {
         const newPrefix = prefix + (isLast ? '    ' : '│   ');
         children.forEach((child, index) => {
             const isChildLast = index === children.length - 1;
-            displayTaskTree(taskService, child, newPrefix, isChildLast, allTasksMetadata);
+            displayTaskTree(child, childrenByParentId, newPrefix, isChildLast, allTasksMetadata);
         });
     }
 }
 /**
  * Build a tree node from a task, including children recursively.
  */
-function buildTreeNode(task, taskService, allTaskTags, allTasksMetadata) {
-    const tags = allTaskTags.get(task.id);
-    const metadata = allTasksMetadata.get(task.id);
-    const children = taskService.getChildTasks(task.id);
+function buildTreeNode(task, childrenByParentId, allTaskTags, allTasksMetadata) {
+    const children = childrenByParentId.get(task.id) || [];
     return {
-        id: task.id,
-        title: task.title,
-        body: task.body,
-        author: task.author,
-        assignees: task.assignees,
-        status: task.status,
-        priority: task.priority,
-        parent_id: task.parent_id,
-        created_at: task.created_at,
-        updated_at: task.updated_at,
-        tags: tags ? tags.map((tag) => ({ id: tag.id, name: tag.name })) : [],
-        metadata: metadata ? metadata.map((m) => ({ key: m.key, value: m.value })) : [],
-        children: children.map((child) => buildTreeNode(child, taskService, allTaskTags, allTasksMetadata)),
+        ...mapTaskFields(task, allTaskTags, allTasksMetadata),
+        children: children.map((child) => buildTreeNode(child, childrenByParentId, allTaskTags, allTasksMetadata)),
     };
 }
+/**
+ * Determine the root tasks to render for tree view output. A task is a root
+ * if none of its ancestors (walked via the full, unfiltered taskById map) are
+ * present in the filtered result set (pseudo-root). Without this, a filter
+ * (e.g. `-s in_progress`) that only matches child tasks would report a
+ * non-zero count while rendering nothing, since the real root would be
+ * filtered out.
+ *
+ * Checking the entire ancestor chain (not just the immediate parent) avoids
+ * rendering a task twice: if some ancestor is in the display set, that
+ * ancestor will itself become a root (or a pseudo-root) and its full,
+ * unfiltered subtree — which already includes this task — gets printed.
+ */
+function getTreeRootTasks(displayTasks, taskById) {
+    const displayTaskIds = new Set(displayTasks.map((task) => task.id));
+    return displayTasks.filter((task) => {
+        let current = task;
+        while (current.parent_id != null) {
+            if (displayTaskIds.has(current.parent_id)) {
+                return false;
+            }
+            const parent = taskById.get(current.parent_id);
+            if (!parent) {
+                break;
+            }
+            current = parent;
+        }
+        return true;
+    });
+}
 /**
  * Build the JSON output object for the tree view.
  */
-function buildTreeJsonOutput(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata) {
-    const rootTasks = displayTasks.filter((task) => !task.parent_id);
+function buildTreeJsonOutput(displayTasks, options, tagIds, childrenByParentId, taskById, allTaskTags, allTasksMetadata) {
+    const rootTasks = getTreeRootTasks(displayTasks, taskById);
     return {
         totalCount: displayTasks.length,
         viewMode: 'tree',
@@ -87,14 +160,14 @@ function buildTreeJsonOutput(displayTasks, options, tagIds, taskService, allTask
         },
         sort: options.sort || 'created_at',
         order: options.order || 'desc',
-        tasks: rootTasks.map((task) => buildTreeNode(task, taskService, allTaskTags, allTasksMetadata)),
+        tasks: rootTasks.map((task) => buildTreeNode(task, childrenByParentId, allTaskTags, allTasksMetadata)),
     };
 }
 /**
  * Build the JSON output object for the normal (flat) list view.
  */
-function buildListJsonOutput(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata) {
-    const tasksWithRelations = displayTasks.map((task) => buildTaskWithRelations(task, taskService, allTaskTags, allTasksMetadata));
+function buildListJsonOutput(displayTasks, options, tagIds, taskById, allTaskTags, allTasksMetadata) {
+    const tasksWithRelations = displayTasks.map((task) => buildTaskWithRelations(task, taskById, allTaskTags, allTasksMetadata));
     return {
         totalCount: displayTasks.length,
         filters: {
@@ -113,24 +186,11 @@ function buildListJsonOutput(displayTasks, options, tagIds, taskService, allTask
 /**
  * Build a single task object with parent, tags and metadata relations.
  */
-function buildTaskWithRelations(task, taskService, allTaskTags, allTasksMetadata) {
-    const tags = allTaskTags.get(task.id);
-    const metadata = allTasksMetadata.get(task.id);
-    const parent = task.parent_id ? taskService.getTask(task.parent_id) : null;
+function buildTaskWithRelations(task, taskById, allTaskTags, allTasksMetadata) {
+    const parent = task.parent_id ? (taskById.get(task.parent_id) ?? null) : null;
     return {
-        id: task.id,
-        title: task.title,
-        body: task.body,
-        author: task.author,
-        assignees: task.assignees,
-        status: task.status,
-        priority: task.priority,
-        parent_id: task.parent_id,
-        created_at: task.created_at,
-        updated_at: task.updated_at,
+        ...mapTaskFields(task, allTaskTags, allTasksMetadata),
         parent: parent ? { id: parent.id, title: parent.title, status: parent.status } : null,
-        tags: tags ? tags.map((tag) => ({ id: tag.id, name: tag.name })) : [],
-        metadata: metadata ? metadata.map((m) => ({ key: m.key, value: m.value })) : [],
     };
 }
 /**
@@ -158,65 +218,35 @@ function collectAllBlockedIds(blockMap) {
     }
     return allBlockedIds;
 }
-/**
- * Display a single task node line with optional metadata and relationship label.
- */
-function printTreeNodeLine(task, allTasksMetadata, prefix, isLast, relationshipLabel) {
-    const statusColor = (0, format_1.getStatusColor)(task.status);
-    const connector = isLast ? '\u2514\u2500\u2500 ' : '\u251c\u2500\u2500 ';
-    const labelStr = relationshipLabel ? `${chalk_1.default.gray(relationshipLabel)} ` : '';
-    console.log(`${prefix}${connector}${labelStr}${chalk_1.default.bold.cyan(`[${task.id}]`)} ${chalk_1.default.bold(task.title)} ` +
-        `${chalk_1.default[statusColor](`(${task.status})`)}`);
-    const childPrefix = prefix + (isLast ? '    ' : '\u2502   ');
-    if (task.priority) {
-        console.log(`${childPrefix}${formatPriority(task.priority)}`);
-    }
-    const metadata = allTasksMetadata.get(task.id);
-    if (metadata && metadata.length > 0) {
-        const metadataStrings = metadata.map(formatMetadataEntry);
-        console.log(`${childPrefix}${chalk_1.default.bold('Metadata:')} ${metadataStrings.join(', ')}`);
-    }
-}
 /**
  * Recursively display dependency tree (blocker -> blocked only).
  */
-function displayDependencyTree(task, taskService, blockMap, allTasksMetadata, prefix, isLast, visited, relationshipLabel) {
-    printTreeNodeLine(task, allTasksMetadata, prefix, isLast, relationshipLabel);
+function displayDependencyTree(task, taskById, blockMap, allTasksMetadata, prefix, isLast, visited, relationshipLabel) {
+    printTreeNode(task, allTasksMetadata, prefix, isLast, relationshipLabel);
     if (visited.has(task.id)) {
         return;
     }
     visited.add(task.id);
     const blockedIds = blockMap.get(task.id) || [];
-    const newPrefix = prefix + (isLast ? '    ' : '\u2502   ');
+    const newPrefix = prefix + (isLast ? '    ' : '│   ');
     blockedIds.forEach((blockedId, index) => {
-        const childTask = taskService.getTask(blockedId);
+        const childTask = taskById.get(blockedId);
         if (childTask && !visited.has(blockedId)) {
             const isChildLast = index === blockedIds.length - 1;
-            displayDependencyTree(childTask, taskService, blockMap, allTasksMetadata, newPrefix, isChildLast, new Set(visited), '[blocks]');
+            displayDependencyTree(childTask, taskById, blockMap, allTasksMetadata, newPrefix, isChildLast, new Set(visited), '[blocks]');
         }
     });
 }
-/**
- * Extract tags and metadata for a task.
- */
-function extractTaskRelations(task, allTaskTags, allTasksMetadata) {
-    const tags = allTaskTags.get(task.id);
-    const metadata = allTasksMetadata.get(task.id);
-    return {
-        tags: tags ? tags.map((tag) => ({ id: tag.id, name: tag.name })) : [],
-        metadata: metadata ? metadata.map((m) => ({ key: m.key, value: m.value })) : [],
-    };
-}
 /**
  * Build blocked task nodes recursively.
  */
-function buildBlockedNodes(blockedIds, taskService, blockMap, allTaskTags, allTasksMetadata, visited) {
+function buildBlockedNodes(blockedIds, taskById, blockMap, allTaskTags, allTasksMetadata, visited) {
     const blocks = [];
     for (const blockedId of blockedIds) {
         if (!visited.has(blockedId)) {
-            const blockedTask = taskService.getTask(blockedId);
+            const blockedTask = taskById.get(blockedId);
             if (blockedTask) {
-                blocks.push(buildDepTreeNode(blockedTask, taskService, blockMap, allTaskTags, allTasksMetadata, new Set(visited)));
+                blocks.push(buildDepTreeNode(blockedTask, taskById, blockMap, allTaskTags, allTasksMetadata, new Set(visited)));
             }
         }
     }
@@ -225,31 +255,19 @@ function buildBlockedNodes(blockedIds, taskService, blockMap, allTaskTags, allTa
 /**
  * Build a dependency tree node recursively (blocking relationships only).
  */
-function buildDepTreeNode(task, taskService, blockMap, allTaskTags, allTasksMetadata, visited) {
+function buildDepTreeNode(task, taskById, blockMap, allTaskTags, allTasksMetadata, visited) {
     visited.add(task.id);
     const blockedIds = blockMap.get(task.id) || [];
-    const { tags, metadata } = extractTaskRelations(task, allTaskTags, allTasksMetadata);
-    const blocks = buildBlockedNodes(blockedIds, taskService, blockMap, allTaskTags, allTasksMetadata, visited);
+    const blocks = buildBlockedNodes(blockedIds, taskById, blockMap, allTaskTags, allTasksMetadata, visited);
     return {
-        id: task.id,
-        title: task.title,
-        body: task.body,
-        author: task.author,
-        assignees: task.assignees,
-        status: task.status,
-        priority: task.priority,
-        parent_id: task.parent_id,
-        created_at: task.created_at,
-        updated_at: task.updated_at,
-        tags,
-        metadata,
+        ...mapTaskFields(task, allTaskTags, allTasksMetadata),
         blocks,
     };
 }
 /**
  * Build the JSON output for dep-tree view.
  */
-function buildDepTreeJsonOutput(displayTasks, options, tagIds, taskService, blockMap, allTaskTags, allTasksMetadata) {
+function buildDepTreeJsonOutput(displayTasks, options, tagIds, taskById, blockMap, allTaskTags, allTasksMetadata) {
     const allBlockedIds = collectAllBlockedIds(blockMap);
     const rootTasks = displayTasks.filter((task) => !allBlockedIds.has(task.id));
     return {
@@ -263,7 +281,7 @@ function buildDepTreeJsonOutput(displayTasks, options, tagIds, taskService, bloc
             all: options.all || false,
             priority: options.priority || null,
         },
-        tasks: rootTasks.map((task) => buildDepTreeNode(task, taskService, blockMap, allTaskTags, allTasksMetadata, new Set())),
+        tasks: rootTasks.map((task) => buildDepTreeNode(task, taskById, blockMap, allTaskTags, allTasksMetadata, new Set())),
     };
 }
 /**
@@ -307,10 +325,10 @@ function printTaskPersonInfo(task) {
 /**
  * Print task parent reference.
  */
-function printTaskParent(task, taskService) {
+function printTaskParent(task, taskById) {
     if (!task.parent_id)
         return;
-    const parentTask = taskService.getTask(task.parent_id);
+    const parentTask = taskById.get(task.parent_id);
     if (parentTask) {
         console.log(`  ${chalk_1.default.bold('Parent:')} ${chalk_1.default.cyan(`[${parentTask.id}]`)} ${parentTask.title}`);
     }
@@ -360,10 +378,10 @@ function printTaskSeparator(isLast) {
 /**
  * Print a single task row in the human-readable list view.
  */
-function printTaskRow(task, taskService, allTaskTags, allTasksMetadata, isLast) {
+function printTaskRow(task, taskById, allTaskTags, allTasksMetadata, isLast) {
     printTaskHeader(task);
     printTaskPersonInfo(task);
-    printTaskParent(task, taskService);
+    printTaskParent(task, taskById);
     printTaskPriority(task);
     printTaskTags(task.id, allTaskTags);
     printTaskMetadata(task.id, allTasksMetadata);
@@ -379,17 +397,31 @@ function parseStatusFilter(statusStr) {
         .map((s) => s.trim())
         .filter((s) => s !== '');
 }
+/**
+ * Validation error for task list command options.
+ * Carries the exact text-mode rendering previously passed to formatter.error,
+ * so the action's catch (setupTaskListCommand) can reproduce identical output
+ * while owning the single process.exit(1) call site.
+ */
+class TaskListValidationError extends errors_1.ValidationError {
+    render;
+    constructor(message, render) {
+        super(message);
+        this.render = render;
+        this.name = 'TaskListValidationError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
 /**
  * Validate status values.
  */
-function validateStatuses(statuses, formatter) {
+function validateStatuses(statuses) {
     for (const s of statuses) {
         if (!(0, validators_1.validateTaskStatus)(s)) {
-            formatter.error(`Invalid status: ${s}. Valid statuses: icebox, backlog, ready, in_progress, review, done, closed`, () => {
-                console.log(chalk_1.default.red(`Invalid status: ${s}`));
-                console.log('Valid statuses: icebox, backlog, ready, in_progress, review, done, closed');
+            throw new TaskListValidationError(`Invalid status: ${s}. Valid statuses: icebox, backlog, ready, in_progress, review, done, closed`, () => {
+                console.error(chalk_1.default.red(`Invalid status: ${s}`));
+                console.error('Valid statuses: icebox, backlog, ready, in_progress, review, done, closed');
             });
-            process.exit(1);
         }
     }
 }
@@ -402,25 +434,23 @@ function normalizeStatusFilter(statusParts) {
 /**
  * Validate sort field.
  */
-function validateSortField(sortField, formatter) {
+function validateSortField(sortField) {
     if (!TaskService_1.ALLOWED_SORT_FIELDS.includes(sortField)) {
-        formatter.error(`Invalid sort field: ${sortField}. Valid fields: ${TaskService_1.ALLOWED_SORT_FIELDS.join(', ')}`, () => {
-            console.log(chalk_1.default.red(`Invalid sort field: ${sortField}`));
-            console.log(`Valid fields: ${TaskService_1.ALLOWED_SORT_FIELDS.join(', ')}`);
+        throw new TaskListValidationError(`Invalid sort field: ${sortField}. Valid fields: ${TaskService_1.ALLOWED_SORT_FIELDS.join(', ')}`, () => {
+            console.error(chalk_1.default.red(`Invalid sort field: ${sortField}`));
+            console.error(`Valid fields: ${TaskService_1.ALLOWED_SORT_FIELDS.join(', ')}`);
         });
-        process.exit(1);
     }
 }
 /**
  * Validate sort order.
  */
-function validateSortOrder(sortOrder, formatter) {
+function validateSortOrder(sortOrder) {
     if (!['asc', 'desc'].includes(sortOrder)) {
-        formatter.error(`Invalid sort order: ${sortOrder}. Valid orders: asc, desc`, () => {
-            console.log(chalk_1.default.red(`Invalid sort order: ${sortOrder}`));
-            console.log('Valid orders: asc, desc');
+        throw new TaskListValidationError(`Invalid sort order: ${sortOrder}. Valid orders: asc, desc`, () => {
+            console.error(chalk_1.default.red(`Invalid sort order: ${sortOrder}`));
+            console.error('Valid orders: asc, desc');
         });
-        process.exit(1);
     }
 }
 /**
@@ -435,14 +465,13 @@ function parsePriorityFilter(priorityStr) {
 /**
  * Validate priority values.
  */
-function validatePriorities(priorities, formatter) {
+function validatePriorities(priorities) {
     for (const p of priorities) {
         if (!(0, models_1.isPriority)(p)) {
-            formatter.error(`Invalid priority: ${p}. Valid priorities: ${models_1.PRIORITIES.join(', ')}`, () => {
-                console.log(chalk_1.default.red(`Invalid priority: ${p}`));
-                console.log(`Valid priorities: ${models_1.PRIORITIES.join(', ')}`);
+            throw new TaskListValidationError(`Invalid priority: ${p}. Valid priorities: ${models_1.PRIORITIES.join(', ')}`, () => {
+                console.error(chalk_1.default.red(`Invalid priority: ${p}`));
+                console.error(`Valid priorities: ${models_1.PRIORITIES.join(', ')}`);
             });
-            process.exit(1);
         }
     }
 }
@@ -455,9 +484,9 @@ function normalizePriorityFilter(priorityParts) {
 /**
  * Resolve tag filter from options to an array of tag IDs.
  * Returns undefined if no tag filter is specified.
- * Exits with error if tag filter is invalid.
+ * Throws TaskListValidationError if the tag filter is invalid.
  */
-function resolveTagIds(tagOption, tagService, formatter) {
+function resolveTagIds(tagOption, tagService) {
     if (!tagOption) {
         return undefined;
     }
@@ -466,20 +495,18 @@ function resolveTagIds(tagOption, tagService, formatter) {
         .map((s) => s.trim())
         .filter((s) => s !== '');
     if (parts.length === 0) {
-        formatter.error('Invalid tag filter. Provide tag IDs or names.', () => {
-            console.log(chalk_1.default.red('\nError: Invalid tag filter. Provide tag IDs or names.\n'));
+        throw new TaskListValidationError('Invalid tag filter. Provide tag IDs or names.', () => {
+            console.error(chalk_1.default.red('\nError: Invalid tag filter. Provide tag IDs or names.\n'));
         });
-        process.exit(1);
     }
     const tagIds = [];
     for (const part of parts) {
         const { tag, byId } = (0, tag_resolver_1.resolveTag)(tagService, part);
         if (!tag) {
             const message = byId ? `Tag with ID "${part}" not found` : `Tag with name "${part}" not found`;
-            formatter.error(message, () => {
-                console.log(chalk_1.default.red(`\nError: ${message}\n`));
+            throw new TaskListValidationError(message, () => {
+                console.error(chalk_1.default.red(`\nError: ${message}\n`));
             });
-            process.exit(1);
         }
         tagIds.push(tag.id);
     }
@@ -488,14 +515,14 @@ function resolveTagIds(tagOption, tagService, formatter) {
 /**
  * Handle tree view output.
  */
-function handleTreeView(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata, formatter) {
-    const rootTasks = displayTasks.filter((task) => !task.parent_id);
-    formatter.output(() => buildTreeJsonOutput(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata), () => {
+function handleTreeView(displayTasks, options, tagIds, childrenByParentId, taskById, allTaskTags, allTasksMetadata, formatter) {
+    const rootTasks = getTreeRootTasks(displayTasks, taskById);
+    formatter.output(() => buildTreeJsonOutput(displayTasks, options, tagIds, childrenByParentId, taskById, allTaskTags, allTasksMetadata), () => {
         console.log(chalk_1.default.bold(`\nFound ${displayTasks.length} task(s) in tree view:\n`));
         console.log(chalk_1.default.bold('─'.repeat(80)));
         rootTasks.forEach((task, index) => {
             const isLast = index === rootTasks.length - 1;
-            displayTaskTree(taskService, task, '', isLast, allTasksMetadata);
+            displayTaskTree(task, childrenByParentId, '', isLast, allTasksMetadata);
         });
         console.log('\n');
     });
@@ -503,16 +530,16 @@ function handleTreeView(displayTasks, options, tagIds, taskService, allTaskTags,
 /**
  * Handle dependency tree view output.
  */
-function handleDepTreeView(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata, taskBlockService, formatter) {
+function handleDepTreeView(displayTasks, options, tagIds, taskById, allTaskTags, allTasksMetadata, taskBlockService, formatter) {
     const blockMap = buildBlockMap(taskBlockService);
     const allBlockedIds = collectAllBlockedIds(blockMap);
     const rootTasks = displayTasks.filter((task) => !allBlockedIds.has(task.id));
-    formatter.output(() => buildDepTreeJsonOutput(displayTasks, options, tagIds, taskService, blockMap, allTaskTags, allTasksMetadata), () => {
+    formatter.output(() => buildDepTreeJsonOutput(displayTasks, options, tagIds, taskById, blockMap, allTaskTags, allTasksMetadata), () => {
         console.log(chalk_1.default.bold(`\nFound ${displayTasks.length} task(s) in dependency tree view:\n`));
-        console.log(chalk_1.default.bold('\u2500'.repeat(80)));
+        console.log(chalk_1.default.bold('─'.repeat(80)));
         rootTasks.forEach((task, index) => {
             const isLast = index === rootTasks.length - 1;
-            displayDependencyTree(task, taskService, blockMap, allTasksMetadata, '', isLast, new Set());
+            displayDependencyTree(task, taskById, blockMap, allTasksMetadata, '', isLast, new Set());
         });
         console.log('\n');
     });
@@ -520,13 +547,13 @@ function handleDepTreeView(displayTasks, options, tagIds, taskService, allTaskTa
 /**
  * Handle normal list view output.
  */
-function handleListView(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata, formatter) {
-    formatter.output(() => buildListJsonOutput(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata), () => {
+function handleListView(displayTasks, options, tagIds, taskById, allTaskTags, allTasksMetadata, formatter) {
+    formatter.output(() => buildListJsonOutput(displayTasks, options, tagIds, taskById, allTaskTags, allTasksMetadata), () => {
         console.log(chalk_1.default.bold(`\nFound ${displayTasks.length} task(s):\n`));
         console.log(chalk_1.default.bold('─'.repeat(80)));
         displayTasks.forEach((task, index) => {
             const isLast = index === displayTasks.length - 1;
-            printTaskRow(task, taskService, allTaskTags, allTasksMetadata, isLast);
+            printTaskRow(task, taskById, allTaskTags, allTasksMetadata, isLast);
         });
         console.log('\n');
     });
@@ -570,41 +597,44 @@ function handleEmptyResults(options, tagIds, tasks, formatter) {
 /**
  * Resolve all filter parameters from command options.
  */
-function resolveFilters(options, tagService, formatter) {
+function resolveFilters(options, tagService) {
     // Validate and normalize status filter
     let statusFilter;
     if (options.status) {
         const statusParts = parseStatusFilter(options.status);
-        validateStatuses(statusParts, formatter);
+        validateStatuses(statusParts);
         statusFilter = normalizeStatusFilter(statusParts);
     }
     // Validate sort field and order
     if (options.sort) {
-        validateSortField(options.sort, formatter);
+        validateSortField(options.sort);
     }
     if (options.order) {
-        validateSortOrder(options.order, formatter);
+        validateSortOrder(options.order);
     }
     // Parse and resolve tag filter
-    const tagIds = resolveTagIds(options.tag, tagService, formatter);
+    const tagIds = resolveTagIds(options.tag, tagService);
     // Validate and normalize priority filter
     let priorityFilter;
     if (options.priority) {
         const priorityParts = parsePriorityFilter(options.priority);
-        validatePriorities(priorityParts, formatter);
+        validatePriorities(priorityParts);
         priorityFilter = normalizePriorityFilter(priorityParts);
     }
     return { statusFilter, tagIds, priorityFilter };
 }
 /**
- * Fetch task data and relations (tags, metadata, blocks).
+ * Fetch task data and relations (tags, metadata, blocks, parent/children maps).
  */
-function fetchTaskRelations() {
+function fetchTaskRelations(taskService) {
     const { taskTagService, metadataService, taskBlockService } = (0, service_container_1.getServiceContainer)();
+    const { taskById, childrenByParentId } = buildTaskMaps(taskService);
     return {
         allTaskTags: taskTagService.getAllTaskTags(),
         allTasksMetadata: metadataService.getAllTasksMetadata(),
         taskBlockService,
+        taskById,
+        childrenByParentId,
     };
 }
 /**
@@ -627,21 +657,21 @@ function queryAndFilterTasks(taskService, options, statusFilter, tagIds, priorit
  */
 async function executeListAction(options, formatter) {
     const { taskService, tagService } = (0, service_container_1.getServiceContainer)();
-    const { statusFilter, tagIds, priorityFilter } = resolveFilters(options, tagService, formatter);
+    const { statusFilter, tagIds, priorityFilter } = resolveFilters(options, tagService);
     const { displayTasks, allTasks } = queryAndFilterTasks(taskService, options, statusFilter, tagIds, priorityFilter);
     if (displayTasks.length === 0) {
         handleEmptyResults(options, tagIds, allTasks, formatter);
         return;
     }
-    const { allTaskTags, allTasksMetadata, taskBlockService } = fetchTaskRelations();
+    const { allTaskTags, allTasksMetadata, taskBlockService, taskById, childrenByParentId } = fetchTaskRelations(taskService);
     if (options.tree) {
-        handleTreeView(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata, formatter);
+        handleTreeView(displayTasks, options, tagIds, childrenByParentId, taskById, allTaskTags, allTasksMetadata, formatter);
     }
     else if (options.depTree) {
-        handleDepTreeView(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata, taskBlockService, formatter);
+        handleDepTreeView(displayTasks, options, tagIds, taskById, allTaskTags, allTasksMetadata, taskBlockService, formatter);
     }
     else {
-        handleListView(displayTasks, options, tagIds, taskService, allTaskTags, allTasksMetadata, formatter);
+        handleListView(displayTasks, options, tagIds, taskById, allTaskTags, allTasksMetadata, formatter);
     }
 }
 function setupTaskListCommand(program) {
@@ -671,12 +701,15 @@ function setupTaskListCommand(program) {
             await executeListAction(options, formatter);
         }
         catch (error) {
-            if (error instanceof Error) {
+            if (error instanceof TaskListValidationError) {
+                formatter.error(error.message, error.render);
+            }
+            else if (error instanceof Error) {
                 (0, error_handler_1.handleError)(error, options);
             }
             else {
                 formatter.error('An unknown error occurred', () => {
-                    console.log(chalk_1.default.red('\n✗ An unknown error occurred\n'));
+                    console.error(chalk_1.default.red('\n✗ An unknown error occurred\n'));
                 });
             }
             process.exit(1);