@doist/todoist-ai 2.2.2 → 3.0.0

package/dist/tools/find-projects.js

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { mapProject } from '../tool-helpers.js';
+import { ApiLimits } from '../utils/constants.js';
+import { formatProjectPreview, summarizeList } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { MANAGE_PROJECTS, FIND_TASKS } = ToolNames;
+const ArgsSchema = {
+    search: z
+        .string()
+        .optional()
+        .describe('Search for a project by name (partial and case insensitive match). If omitted, all projects are returned.'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(ApiLimits.PROJECTS_MAX)
+        .default(ApiLimits.PROJECTS_DEFAULT)
+        .describe('The maximum number of projects to return.'),
+    cursor: z
+        .string()
+        .optional()
+        .describe('The cursor to get the next page of projects (cursor is obtained from the previous call to this tool, with the same parameters).'),
+};
+const findProjects = {
+    name: ToolNames.FIND_PROJECTS,
+    description: 'List all projects or search for projects by name. If search parameter is omitted, all projects are returned.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { results, nextCursor } = await client.getProjects({
+            limit: args.limit,
+            cursor: args.cursor ?? null,
+        });
+        const searchLower = args.search ? args.search.toLowerCase() : undefined;
+        const filtered = searchLower
+            ? results.filter((project) => project.name.toLowerCase().includes(searchLower))
+            : results;
+        const projects = filtered.map(mapProject);
+        return getToolOutput({
+            textContent: generateTextContent({
+                projects,
+                args,
+                nextCursor,
+            }),
+            structuredContent: {
+                projects,
+                nextCursor,
+                totalCount: projects.length,
+                hasMore: Boolean(nextCursor),
+                appliedFilters: args,
+            },
+        });
+    },
+};
+function generateTextContent({ projects, args, nextCursor, }) {
+    // Generate subject description
+    const subject = args.search ? `Projects matching "${args.search}"` : 'Projects';
+    // Generate filter hints
+    const filterHints = [];
+    if (args.search) {
+        filterHints.push(`search: "${args.search}"`);
+    }
+    // Generate project preview lines
+    const previewLimit = 10;
+    const previewProjects = projects.slice(0, previewLimit);
+    const previewLines = previewProjects.map(formatProjectPreview).join('\n');
+    const remainingCount = projects.length - previewLimit;
+    const previewWithMore = remainingCount > 0 ? `${previewLines}\n    …and ${remainingCount} more` : previewLines;
+    // Generate helpful suggestions for empty results
+    const zeroReasonHints = [];
+    if (projects.length === 0) {
+        if (args.search) {
+            zeroReasonHints.push('Try broader search terms');
+            zeroReasonHints.push('Check spelling');
+            zeroReasonHints.push('Remove search to see all projects');
+        }
+        else {
+            zeroReasonHints.push('No projects created yet');
+            zeroReasonHints.push(`Use ${MANAGE_PROJECTS} to create a project`);
+        }
+    }
+    // Generate contextual next steps
+    const nextSteps = [];
+    if (projects.length > 0) {
+        nextSteps.push(`Use ${FIND_TASKS} with projectId to see tasks in specific projects.`);
+        if (projects.some((p) => p.isFavorite)) {
+            nextSteps.push('Favorite projects appear first in most Todoist views.');
+        }
+    }
+    return summarizeList({
+        subject,
+        count: projects.length,
+        limit: args.limit,
+        nextCursor: nextCursor ?? undefined,
+        filterHints,
+        previewLines: previewWithMore,
+        zeroReasonHints,
+        nextSteps,
+    });
+}
+export { findProjects };

package/dist/tools/find-sections.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+declare const findSections: {
+    name: "find-sections";
+    description: string;
+    parameters: {
+        projectId: z.ZodString;
+        search: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        projectId: string;
+        search?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            sections: {
+                id: string;
+                name: string;
+            }[];
+            totalCount: number;
+            appliedFilters: {
+                projectId: string;
+                search?: string | undefined;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { findSections };
+//# sourceMappingURL=find-sections.d.ts.map

package/dist/tools/find-sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-sections.d.ts","sourceRoot":"","sources":["../../src/tools/find-sections.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCwB,CAAA;AAqE1C,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/find-sections.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { summarizeList } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { MANAGE_SECTIONS, FIND_TASKS, UPDATE_TASKS, DELETE_OBJECT } = ToolNames;
+const ArgsSchema = {
+    projectId: z.string().min(1).describe('The ID of the project to search sections in.'),
+    search: z
+        .string()
+        .optional()
+        .describe('Search for a section by name (partial and case insensitive match). If omitted, all sections in the project are returned.'),
+};
+const findSections = {
+    name: ToolNames.FIND_SECTIONS,
+    description: 'Search for sections by name or other criteria in a project.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { results } = await client.getSections({
+            projectId: args.projectId,
+        });
+        const searchLower = args.search ? args.search.toLowerCase() : undefined;
+        const filtered = searchLower
+            ? results.filter((section) => section.name.toLowerCase().includes(searchLower))
+            : results;
+        const sections = filtered.map((section) => ({
+            id: section.id,
+            name: section.name,
+        }));
+        const textContent = generateTextContent({
+            sections,
+            projectId: args.projectId,
+            search: args.search,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                sections,
+                totalCount: sections.length,
+                appliedFilters: args,
+            },
+        });
+    },
+};
+function generateTextContent({ sections, projectId, search, }) {
+    const zeroReasonHints = [];
+    if (search) {
+        zeroReasonHints.push('Try broader search terms');
+        zeroReasonHints.push('Check spelling');
+        zeroReasonHints.push('Remove search to see all sections');
+    }
+    else {
+        zeroReasonHints.push('Project has no sections yet');
+        zeroReasonHints.push(`Use ${MANAGE_SECTIONS} to create sections`);
+    }
+    // Data-driven next steps based on results
+    const nextSteps = [];
+    if (sections.length > 0) {
+        // Suggestions based on number of sections found
+        if (sections.length === 1) {
+            const sectionId = sections[0]?.id;
+            nextSteps.push(`Use ${FIND_TASKS} with sectionId=${sectionId} to see tasks`);
+            nextSteps.push(`Use ${MANAGE_SECTIONS} to create additional sections for organization`);
+        }
+        else if (sections.length > 8) {
+            nextSteps.push('Consider consolidating sections - many small sections can reduce productivity');
+            nextSteps.push(`Use ${UPDATE_TASKS} to move tasks between sections`);
+            nextSteps.push(`Use ${DELETE_OBJECT} with type=section to delete empty sections`);
+        }
+        else {
+            nextSteps.push(`Use ${FIND_TASKS} with sectionId to see tasks in specific sections`);
+            nextSteps.push(`Use ${MANAGE_SECTIONS} to modify section names or order`);
+        }
+        // Search-specific suggestions
+        if (search) {
+            nextSteps.push('Remove search parameter to see all sections in this project');
+        }
+    }
+    else {
+        // Empty result suggestions are already handled in zeroReasonHints
+        // No additional nextSteps needed for empty results
+    }
+    const subject = search
+        ? `Sections in project ${projectId} matching "${search}"`
+        : `Sections in project ${projectId}`;
+    const previewLines = sections.length > 0
+        ? sections.map((section) => `    ${section.name} • id=${section.id}`).join('\n')
+        : undefined;
+    return summarizeList({
+        subject,
+        count: sections.length,
+        previewLines,
+        zeroReasonHints,
+        nextSteps,
+    });
+}
+export { findSections };

package/dist/tools/find-tasks-by-date.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+declare const findTasksByDate: {
+    name: "find-tasks-by-date";
+    description: string;
+    parameters: {
+        startDate: z.ZodString;
+        daysCount: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        startDate: string;
+        daysCount: number;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            tasks: {
+                id: string;
+                content: string;
+                description: string;
+                dueDate: string | undefined;
+                recurring: string | boolean;
+                priority: number;
+                projectId: string;
+                sectionId: string | null;
+                parentId: string | null;
+                labels: string[];
+                duration: string | null;
+            }[];
+            nextCursor: string | null;
+            totalCount: number;
+            hasMore: boolean;
+            appliedFilters: {
+                limit: number;
+                startDate: string;
+                daysCount: number;
+                cursor?: string | undefined;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { findTasksByDate };
+//# sourceMappingURL=find-tasks-by-date.d.ts.map

package/dist/tools/find-tasks-by-date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-tasks-by-date.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks-by-date.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA4CvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CqB,CAAA;AAiE1C,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/tools/find-tasks-by-date.js

@@ -0,0 +1,121 @@
+import { addDays, formatISO } from 'date-fns';
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { getTasksByFilter } from '../tool-helpers.js';
+import { ApiLimits } from '../utils/constants.js';
+import { generateTaskNextSteps, getDateString, previewTasks, summarizeList, } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    startDate: z
+        .string()
+        .regex(/^(\d{4}-\d{2}-\d{2}|today|overdue)$/)
+        .describe("The start date to get the tasks for. Format: YYYY-MM-DD, 'today', or 'overdue'."),
+    daysCount: z
+        .number()
+        .int()
+        .min(1)
+        .max(30)
+        .default(1)
+        .describe("The number of days to get the tasks for, starting from the start date. Ignored when startDate is 'overdue'."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(ApiLimits.TASKS_MAX)
+        .default(ApiLimits.TASKS_DEFAULT)
+        .describe('The maximum number of tasks to return.'),
+    cursor: z
+        .string()
+        .optional()
+        .describe('The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters).'),
+};
+const findTasksByDate = {
+    name: ToolNames.FIND_TASKS_BY_DATE,
+    description: "Get tasks by date range or overdue tasks. Use startDate 'overdue' for overdue tasks, or provide a date/date range.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        let query;
+        if (args.startDate === 'overdue') {
+            query = 'overdue';
+        }
+        else {
+            const startDate = args.startDate === 'today'
+                ? formatISO(new Date(), { representation: 'date' })
+                : args.startDate;
+            const endDate = addDays(startDate, args.daysCount + 1);
+            const endDateStr = formatISO(endDate, { representation: 'date' });
+            query = `(due after: ${startDate} | due: ${startDate}) & due before: ${endDateStr}`;
+        }
+        const result = await getTasksByFilter({
+            client,
+            query,
+            cursor: args.cursor,
+            limit: args.limit,
+        });
+        const textContent = generateTextContent({
+            tasks: result.tasks,
+            args,
+            nextCursor: result.nextCursor,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                tasks: result.tasks,
+                nextCursor: result.nextCursor,
+                totalCount: result.tasks.length,
+                hasMore: Boolean(result.nextCursor),
+                appliedFilters: args,
+            },
+        });
+    },
+};
+function generateTextContent({ tasks, args, nextCursor, }) {
+    // Generate filter description
+    const filterHints = [];
+    if (args.startDate === 'overdue') {
+        filterHints.push('overdue tasks only');
+    }
+    else if (args.startDate === 'today') {
+        filterHints.push(`today${args.daysCount > 1 ? ` + ${args.daysCount - 1} more days` : ''}`);
+    }
+    else {
+        filterHints.push(`${args.startDate}${args.daysCount > 1 ? ` to ${getDateString(addDays(args.startDate, args.daysCount))}` : ''}`);
+    }
+    // Generate subject description
+    const subject = args.startDate === 'overdue'
+        ? 'Overdue tasks'
+        : args.startDate === 'today'
+            ? `Today's tasks`
+            : `Tasks for ${args.startDate}`;
+    // Generate helpful suggestions for empty results
+    const zeroReasonHints = [];
+    if (tasks.length === 0) {
+        if (args.startDate === 'overdue') {
+            zeroReasonHints.push('Great job! No overdue tasks');
+            zeroReasonHints.push("Check today's tasks with startDate='today'");
+        }
+        else {
+            zeroReasonHints.push("Expand date range with larger 'daysCount'");
+            zeroReasonHints.push("Check 'overdue' for past-due items");
+        }
+    }
+    // Generate contextual next steps
+    const now = new Date();
+    const todayStr = getDateString(now);
+    const nextSteps = generateTaskNextSteps('listed', tasks, {
+        hasToday: args.startDate === 'today' || tasks.some((task) => task.dueDate === todayStr),
+        hasOverdue: args.startDate === 'overdue' ||
+            tasks.some((task) => task.dueDate && new Date(task.dueDate) < now),
+    });
+    return summarizeList({
+        subject,
+        count: tasks.length,
+        limit: args.limit,
+        nextCursor: nextCursor ?? undefined,
+        filterHints,
+        previewLines: previewTasks(tasks),
+        zeroReasonHints,
+        nextSteps,
+    });
+}
+export { findTasksByDate };

package/dist/tools/find-tasks.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+declare const findTasks: {
+    name: "find-tasks";
+    description: string;
+    parameters: {
+        searchText: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        sectionId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        parentId?: string | undefined;
+        projectId?: string | undefined;
+        sectionId?: string | undefined;
+        cursor?: string | undefined;
+        searchText?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            tasks: {
+                id: string;
+                content: string;
+                description: string;
+                dueDate: string | undefined;
+                recurring: string | boolean;
+                priority: number;
+                projectId: string;
+                sectionId: string | null;
+                parentId: string | null;
+                labels: string[];
+                duration: string | null;
+            }[];
+            nextCursor: string | null;
+            totalCount: number;
+            hasMore: boolean;
+            appliedFilters: {
+                limit: number;
+                parentId?: string | undefined;
+                projectId?: string | undefined;
+                sectionId?: string | undefined;
+                cursor?: string | undefined;
+                searchText?: string | undefined;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { findTasks };
+//# sourceMappingURL=find-tasks.d.ts.map

package/dist/tools/find-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAoCvB,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmF2B,CAAA;AAyG1C,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/dist/tools/find-tasks.js

@@ -0,0 +1,182 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { getTasksByFilter, mapTask } from '../tool-helpers.js';
+import { ApiLimits } from '../utils/constants.js';
+import { generateTaskNextSteps, getDateString, previewTasks, summarizeList, } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { FIND_COMPLETED_TASKS, ADD_TASKS } = ToolNames;
+const ArgsSchema = {
+    searchText: z.string().optional().describe('The text to search for in tasks.'),
+    projectId: z.string().optional().describe('Find tasks in this project.'),
+    sectionId: z.string().optional().describe('Find tasks in this section.'),
+    parentId: z.string().optional().describe('Find subtasks of this parent task.'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(ApiLimits.TASKS_MAX)
+        .default(ApiLimits.TASKS_DEFAULT)
+        .describe('The maximum number of tasks to return.'),
+    cursor: z
+        .string()
+        .optional()
+        .describe('The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters).'),
+};
+const findTasks = {
+    name: ToolNames.FIND_TASKS,
+    description: 'Find tasks by text search, or by project/section/parent container. At least one filter must be provided.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { searchText, projectId, sectionId, parentId, limit, cursor } = args;
+        // Validate at least one filter is provided
+        if (!searchText && !projectId && !sectionId && !parentId) {
+            throw new Error('At least one filter must be provided: searchText, projectId, sectionId, or parentId');
+        }
+        // If using container-based filtering, use direct API
+        if (projectId || sectionId || parentId) {
+            const taskParams = {
+                limit,
+                cursor: cursor ?? null,
+            };
+            if (projectId)
+                taskParams.projectId = projectId;
+            if (sectionId)
+                taskParams.sectionId = sectionId;
+            if (parentId)
+                taskParams.parentId = parentId;
+            const { results, nextCursor } = await client.getTasks(taskParams);
+            const mappedTasks = results.map(mapTask);
+            // If also has searchText, filter the results
+            const finalTasks = searchText
+                ? mappedTasks.filter((task) => task.content.toLowerCase().includes(searchText.toLowerCase()) ||
+                    task.description?.toLowerCase().includes(searchText.toLowerCase()))
+                : mappedTasks;
+            const textContent = generateTextContent({
+                tasks: finalTasks,
+                args,
+                nextCursor,
+                isContainerSearch: true,
+            });
+            return getToolOutput({
+                textContent,
+                structuredContent: {
+                    tasks: finalTasks,
+                    nextCursor,
+                    totalCount: finalTasks.length,
+                    hasMore: Boolean(nextCursor),
+                    appliedFilters: args,
+                },
+            });
+        }
+        // Text-only search using filter query
+        const result = await getTasksByFilter({
+            client,
+            query: `search: ${searchText}`,
+            cursor: args.cursor,
+            limit: args.limit,
+        });
+        const textContent = generateTextContent({
+            tasks: result.tasks,
+            args,
+            nextCursor: result.nextCursor,
+            isContainerSearch: false,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                tasks: result.tasks,
+                nextCursor: result.nextCursor,
+                totalCount: result.tasks.length,
+                hasMore: Boolean(result.nextCursor),
+                appliedFilters: args,
+            },
+        });
+    },
+};
+function getContainerZeroReasonHints(args) {
+    if (args.projectId) {
+        const hints = [
+            args.searchText ? 'No tasks in project match search' : 'Project has no tasks yet',
+        ];
+        if (!args.searchText) {
+            hints.push(`Use ${ADD_TASKS} to create tasks`);
+        }
+        return hints;
+    }
+    if (args.sectionId) {
+        const hints = [args.searchText ? 'No tasks in section match search' : 'Section is empty'];
+        if (!args.searchText) {
+            hints.push('Tasks may be in other sections of the project');
+        }
+        return hints;
+    }
+    if (args.parentId) {
+        const hints = [args.searchText ? 'No subtasks match search' : 'No subtasks created yet'];
+        if (!args.searchText) {
+            hints.push(`Use ${ADD_TASKS} with parentId to add subtasks`);
+        }
+        return hints;
+    }
+    return [];
+}
+function generateTextContent({ tasks, args, nextCursor, isContainerSearch, }) {
+    // Generate subject and filter descriptions based on search type
+    let subject;
+    const filterHints = [];
+    const zeroReasonHints = [];
+    if (isContainerSearch) {
+        // Container-based search
+        if (args.projectId) {
+            subject = 'Tasks in project';
+            filterHints.push(`in project ${args.projectId}`);
+        }
+        else if (args.sectionId) {
+            subject = 'Tasks in section';
+            filterHints.push(`in section ${args.sectionId}`);
+        }
+        else if (args.parentId) {
+            subject = 'Subtasks';
+            filterHints.push(`subtasks of ${args.parentId}`);
+        }
+        else {
+            subject = 'Tasks'; // fallback, though this shouldn't happen
+        }
+        // Add search text filter if present
+        if (args.searchText) {
+            subject += ` matching "${args.searchText}"`;
+            filterHints.push(`containing "${args.searchText}"`);
+        }
+        // Container-specific zero result hints
+        if (tasks.length === 0) {
+            zeroReasonHints.push(...getContainerZeroReasonHints(args));
+        }
+    }
+    else {
+        // Text-only search
+        subject = `Search results for "${args.searchText}"`;
+        filterHints.push(`matching "${args.searchText}"`);
+        if (tasks.length === 0) {
+            zeroReasonHints.push('Try broader search terms');
+            zeroReasonHints.push(`Check completed tasks with ${FIND_COMPLETED_TASKS}`);
+            zeroReasonHints.push('Verify spelling and try partial words');
+        }
+    }
+    // Generate contextual next steps
+    const now = new Date();
+    const todayDateString = getDateString(now);
+    const nextSteps = generateTaskNextSteps('listed', tasks, {
+        hasToday: tasks.some((task) => task.dueDate === todayDateString),
+        hasOverdue: tasks.some((task) => task.dueDate && new Date(task.dueDate) < now),
+    });
+    return summarizeList({
+        subject,
+        count: tasks.length,
+        limit: args.limit,
+        nextCursor: nextCursor ?? undefined,
+        filterHints,
+        previewLines: previewTasks(tasks),
+        zeroReasonHints,
+        nextSteps,
+    });
+}
+export { findTasks };