@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/tools/fetch.js

@@ -1,102 +0,0 @@
-import { getProjectUrl, getTaskUrl } from '@doist/todoist-api-typescript';
-import { z } from 'zod';
-import { getErrorOutput } from '../mcp-helpers.js';
-import { mapProject, mapTask } from '../tool-helpers.js';
-import { ToolNames } from '../utils/tool-names.js';
-const ArgsSchema = {
-    id: z
-        .string()
-        .min(1)
-        .describe('A unique identifier for the document in the format "task:{id}" or "project:{id}".'),
-};
-/**
- * OpenAI MCP fetch tool - retrieves the full contents of a task or project by ID.
- *
- * This tool follows the OpenAI MCP fetch tool specification:
- * @see https://platform.openai.com/docs/mcp#fetch-tool
- */
-const fetch = {
-    name: ToolNames.FETCH,
-    description: 'Fetch the full contents of a task or project by its ID. The ID should be in the format "task:{id}" or "project:{id}".',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        try {
-            const { id } = args;
-            // Parse the composite ID
-            const [type, objectId] = id.split(':', 2);
-            if (!objectId || (type !== 'task' && type !== 'project')) {
-                throw new Error('Invalid ID format. Expected "task:{id}" or "project:{id}". Example: "task:8485093748" or "project:6cfCcrrCFg2xP94Q"');
-            }
-            let result;
-            if (type === 'task') {
-                // Fetch task
-                const task = await client.getTask(objectId);
-                const mappedTask = mapTask(task);
-                // Build text content
-                const textParts = [mappedTask.content];
-                if (mappedTask.description) {
-                    textParts.push(`\n\nDescription: ${mappedTask.description}`);
-                }
-                if (mappedTask.dueDate) {
-                    textParts.push(`\nDue: ${mappedTask.dueDate}`);
-                }
-                if (mappedTask.labels.length > 0) {
-                    textParts.push(`\nLabels: ${mappedTask.labels.join(', ')}`);
-                }
-                result = {
-                    id: `task:${mappedTask.id}`,
-                    title: mappedTask.content,
-                    text: textParts.join(''),
-                    url: getTaskUrl(mappedTask.id),
-                    metadata: {
-                        priority: mappedTask.priority,
-                        projectId: mappedTask.projectId,
-                        sectionId: mappedTask.sectionId,
-                        parentId: mappedTask.parentId,
-                        recurring: mappedTask.recurring,
-                        duration: mappedTask.duration,
-                        responsibleUid: mappedTask.responsibleUid,
-                        assignedByUid: mappedTask.assignedByUid,
-                        checked: mappedTask.checked,
-                        completedAt: mappedTask.completedAt,
-                    },
-                };
-            }
-            else {
-                // Fetch project
-                const project = await client.getProject(objectId);
-                const mappedProject = mapProject(project);
-                // Build text content
-                const textParts = [mappedProject.name];
-                if (mappedProject.isShared) {
-                    textParts.push('\n\nShared project');
-                }
-                if (mappedProject.isFavorite) {
-                    textParts.push('\nFavorite: Yes');
-                }
-                result = {
-                    id: `project:${mappedProject.id}`,
-                    title: mappedProject.name,
-                    text: textParts.join(''),
-                    url: getProjectUrl(mappedProject.id),
-                    metadata: {
-                        color: mappedProject.color,
-                        isFavorite: mappedProject.isFavorite,
-                        isShared: mappedProject.isShared,
-                        parentId: mappedProject.parentId,
-                        inboxProject: mappedProject.inboxProject,
-                        viewStyle: mappedProject.viewStyle,
-                    },
-                };
-            }
-            // Return as JSON-encoded string in a text content item (OpenAI MCP spec)
-            const jsonText = JSON.stringify(result);
-            return { content: [{ type: 'text', text: jsonText }] };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'An unknown error occurred';
-            return getErrorOutput(message);
-        }
-    },
-};
-export { fetch };

package/dist/tools/find-activity.js

@@ -1,221 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { mapActivityEvent } from '../tool-helpers.js';
-import { ApiLimits } from '../utils/constants.js';
-import { summarizeList } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { FIND_TASKS, USER_INFO } = ToolNames;
-const ArgsSchema = {
-    objectType: z
-        .enum(['task', 'project', 'comment'])
-        .optional()
-        .describe('Type of object to filter by.'),
-    objectId: z
-        .string()
-        .optional()
-        .describe('Filter by specific object ID (task, project, or comment).'),
-    eventType: z
-        .enum([
-        'added',
-        'updated',
-        'deleted',
-        'completed',
-        'uncompleted',
-        'archived',
-        'unarchived',
-        'shared',
-        'left',
-    ])
-        .optional()
-        .describe('Type of event to filter by.'),
-    projectId: z.string().optional().describe('Filter events by parent project ID.'),
-    taskId: z.string().optional().describe('Filter events by parent task ID (for subtask events).'),
-    initiatorId: z.string().optional().describe('Filter by the user ID who initiated the event.'),
-    limit: z
-        .number()
-        .int()
-        .min(1)
-        .max(ApiLimits.ACTIVITY_MAX)
-        .default(ApiLimits.ACTIVITY_DEFAULT)
-        .describe('Maximum number of activity events to return.'),
-    cursor: z
-        .string()
-        .optional()
-        .describe('Pagination cursor for retrieving the next page of results.'),
-};
-const findActivity = {
-    name: ToolNames.FIND_ACTIVITY,
-    description: 'Retrieve recent activity logs to monitor and audit changes in Todoist. Shows events from all users by default (use initiatorId to filter by specific user). Track task completions, updates, deletions, project changes, and more with flexible filtering. Note: Date-based filtering is not supported by the Todoist API.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { objectType, objectId, eventType, projectId, taskId, initiatorId, limit, cursor } = args;
-        // Build API arguments
-        const apiArgs = {
-            limit,
-            cursor: cursor ?? null,
-        };
-        // Add optional filters
-        if (objectType)
-            apiArgs.objectType = objectType;
-        if (objectId && objectId !== 'remove')
-            apiArgs.objectId = objectId;
-        if (eventType)
-            apiArgs.eventType = eventType;
-        if (projectId)
-            apiArgs.parentProjectId = projectId;
-        if (taskId)
-            apiArgs.parentItemId = taskId;
-        if (initiatorId)
-            apiArgs.initiatorId = initiatorId;
-        // Fetch activity logs from API
-        const { results, nextCursor } = await client.getActivityLogs(apiArgs);
-        const events = results.map(mapActivityEvent);
-        // Generate text content
-        const textContent = generateTextContent({
-            events,
-            args,
-            nextCursor,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                events,
-                nextCursor,
-                totalCount: events.length,
-                hasMore: Boolean(nextCursor),
-                appliedFilters: args,
-            },
-        });
-    },
-};
-function generateTextContent({ events, args, nextCursor, }) {
-    // Generate subject description
-    let subject = 'Activity events';
-    // Build subject based on filters
-    const subjectParts = [];
-    if (args.eventType) {
-        subjectParts.push(`${args.eventType}`);
-    }
-    if (args.objectType) {
-        const objectLabel = args.objectType === 'task' ? 'tasks' : `${args.objectType}s`;
-        subjectParts.push(objectLabel);
-    }
-    if (subjectParts.length > 0) {
-        subject = `Activity: ${subjectParts.join(' ')}`;
-    }
-    // Generate filter hints
-    const filterHints = [];
-    if (args.objectId) {
-        filterHints.push(`object ID: ${args.objectId}`);
-    }
-    if (args.projectId) {
-        filterHints.push(`project: ${args.projectId}`);
-    }
-    if (args.taskId) {
-        filterHints.push(`task: ${args.taskId}`);
-    }
-    if (args.initiatorId) {
-        filterHints.push(`initiator: ${args.initiatorId}`);
-    }
-    // Generate helpful suggestions for empty results
-    const zeroReasonHints = [];
-    if (events.length === 0) {
-        zeroReasonHints.push('No activity events match the specified filters');
-        zeroReasonHints.push('Note: Activity logs only show recent events');
-        if (args.eventType) {
-            zeroReasonHints.push(`Try removing the eventType filter (${args.eventType})`);
-        }
-        if (args.objectType) {
-            zeroReasonHints.push(`Try removing the objectType filter (${args.objectType})`);
-        }
-        if (args.objectId || args.projectId || args.taskId) {
-            zeroReasonHints.push('Verify the object ID is correct');
-        }
-    }
-    // Generate contextual next steps
-    const nextSteps = [];
-    if (events.length > 0) {
-        // Suggest related tools based on what was found
-        const hasTaskEvents = events.some((e) => e.objectType === 'task' || e.objectType === 'item');
-        const hasCompletions = events.some((e) => e.eventType === 'completed');
-        if (hasTaskEvents) {
-            nextSteps.push(`Use ${FIND_TASKS} to view current task details`);
-        }
-        if (hasCompletions) {
-            nextSteps.push('Review completed tasks to track productivity');
-        }
-        if (args.initiatorId) {
-            nextSteps.push(`Use ${USER_INFO} to get details about the user`);
-        }
-        // Suggest narrowing down if too many results
-        if (events.length >= args.limit && !nextCursor) {
-            nextSteps.push('Add more specific filters to narrow down results');
-        }
-    }
-    return summarizeList({
-        subject,
-        count: events.length,
-        limit: args.limit,
-        nextCursor: nextCursor ?? undefined,
-        filterHints,
-        previewLines: previewActivityEvents(events, Math.min(events.length, args.limit)),
-        zeroReasonHints,
-        nextSteps,
-    });
-}
-/**
- * Formats activity events into readable preview lines
- */
-function previewActivityEvents(events, limit = 10) {
-    const previewEvents = events.slice(0, limit);
-    const lines = previewEvents.map(formatActivityEventPreview).join('\n');
-    // If we're showing fewer events than the total, add an indicator
-    if (events.length > limit) {
-        const remaining = events.length - limit;
-        return `${lines}\n    ... and ${remaining} more event${remaining === 1 ? '' : 's'}`;
-    }
-    return lines;
-}
-/**
- * Formats a single activity event into a readable preview line
- */
-function formatActivityEventPreview(event) {
-    const date = formatEventDate(event.eventDate);
-    const eventLabel = `${event.eventType} ${event.objectType}`;
-    // Extract useful content from extraData if available
-    let contentInfo = '';
-    if (event.extraData) {
-        const content = event.extraData.content || event.extraData.name || event.extraData.last_content;
-        if (content && typeof content === 'string') {
-            // Truncate long content
-            const truncated = content.length > 50 ? `${content.substring(0, 47)}...` : content;
-            contentInfo = ` • "${truncated}"`;
-        }
-    }
-    const objectId = event.objectId ? ` • id=${event.objectId}` : '';
-    const initiator = event.initiatorId ? ` • by=${event.initiatorId}` : ' • system';
-    const projectInfo = event.parentProjectId ? ` • project=${event.parentProjectId}` : '';
-    return `    [${date}] ${eventLabel}${contentInfo}${objectId}${initiator}${projectInfo}`;
-}
-/**
- * Formats an ISO date string to a more readable format
- */
-function formatEventDate(isoDate) {
-    try {
-        const date = new Date(isoDate);
-        // Format as: Oct 23, 14:30 (in UTC for deterministic snapshots)
-        const month = date.toLocaleDateString('en-US', { month: 'short', timeZone: 'UTC' });
-        const day = date.toLocaleDateString('en-US', { day: 'numeric', timeZone: 'UTC' });
-        const time = date.toLocaleTimeString('en-US', {
-            hour: '2-digit',
-            minute: '2-digit',
-            hour12: false,
-            timeZone: 'UTC',
-        });
-        return `${month} ${day}, ${time}`;
-    }
-    catch {
-        return isoDate;
-    }
-}
-export { findActivity };

package/dist/tools/find-comments.js

@@ -1,143 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { ApiLimits } from '../utils/constants.js';
-import { formatNextSteps } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { ADD_COMMENTS, UPDATE_COMMENTS, DELETE_OBJECT } = ToolNames;
-const ArgsSchema = {
-    taskId: z.string().optional().describe('Find comments for a specific task.'),
-    projectId: z.string().optional().describe('Find comments for a specific project.'),
-    commentId: z.string().optional().describe('Get a specific comment by ID.'),
-    cursor: z.string().optional().describe('Pagination cursor for retrieving more results.'),
-    limit: z
-        .number()
-        .int()
-        .min(1)
-        .max(ApiLimits.COMMENTS_MAX)
-        .optional()
-        .describe('Maximum number of comments to return'),
-};
-const findComments = {
-    name: ToolNames.FIND_COMMENTS,
-    description: 'Find comments by task, project, or get a specific comment by ID. Exactly one of taskId, projectId, or commentId must be provided.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        // Validate that exactly one search parameter is provided
-        const searchParams = [args.taskId, args.projectId, args.commentId].filter(Boolean);
-        if (searchParams.length === 0) {
-            throw new Error('Must provide exactly one of: taskId, projectId, or commentId.');
-        }
-        if (searchParams.length > 1) {
-            throw new Error('Cannot provide multiple search parameters. Choose one of: taskId, projectId, or commentId.');
-        }
-        let comments;
-        let hasMore = false;
-        let nextCursor = null;
-        if (args.commentId) {
-            // Get single comment
-            const comment = await client.getComment(args.commentId);
-            comments = [comment];
-        }
-        else if (args.taskId) {
-            // Get comments by task
-            const response = await client.getComments({
-                taskId: args.taskId,
-                cursor: args.cursor || null,
-                limit: args.limit || ApiLimits.COMMENTS_DEFAULT,
-            });
-            comments = response.results;
-            hasMore = response.nextCursor !== null;
-            nextCursor = response.nextCursor;
-        }
-        else if (args.projectId) {
-            // Get comments by project
-            const response = await client.getComments({
-                projectId: args.projectId,
-                cursor: args.cursor || null,
-                limit: args.limit || ApiLimits.COMMENTS_DEFAULT,
-            });
-            comments = response.results;
-            hasMore = response.nextCursor !== null;
-            nextCursor = response.nextCursor;
-        }
-        else {
-            // This should never happen due to validation, but TypeScript needs it
-            throw new Error('Invalid state: no search parameter provided');
-        }
-        const textContent = generateTextContent({
-            comments,
-            searchType: args.commentId ? 'single' : args.taskId ? 'task' : 'project',
-            searchId: args.commentId || args.taskId || args.projectId || '',
-            hasMore,
-            nextCursor,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                comments,
-                searchType: args.commentId ? 'single' : args.taskId ? 'task' : 'project',
-                searchId: args.commentId || args.taskId || args.projectId || '',
-                hasMore,
-                nextCursor,
-                totalCount: comments.length,
-            },
-        });
-    },
-};
-function generateTextContent({ comments, searchType, searchId, hasMore, nextCursor, }) {
-    if (comments.length === 0) {
-        return `No comments found for ${searchType}${searchType !== 'single' ? ` ${searchId}` : ''}`;
-    }
-    // Build summary
-    let summary;
-    if (searchType === 'single') {
-        const comment = comments[0];
-        if (!comment) {
-            return 'Comment not found';
-        }
-        const hasAttachment = comment.fileAttachment !== null;
-        const attachmentInfo = hasAttachment
-            ? ` • Has attachment: ${comment.fileAttachment?.fileName || 'file'}`
-            : '';
-        summary = `Found comment${attachmentInfo} • id=${comment.id}`;
-    }
-    else {
-        const attachmentCount = comments.filter((c) => c.fileAttachment !== null).length;
-        const attachmentInfo = attachmentCount > 0 ? ` (${attachmentCount} with attachments)` : '';
-        const commentsLabel = comments.length === 1 ? 'comment' : 'comments';
-        summary = `Found ${comments.length} ${commentsLabel} for ${searchType} ${searchId}${attachmentInfo}`;
-        if (hasMore) {
-            summary += ' • More available';
-        }
-    }
-    // Context-aware next steps
-    const nextSteps = [];
-    if (searchType === 'single') {
-        const comment = comments[0];
-        if (comment) {
-            nextSteps.push(`Use ${UPDATE_COMMENTS} with id=${comment.id} to edit content`);
-            nextSteps.push(`Use ${DELETE_OBJECT} with type=comment id=${comment.id} to remove`);
-            // Suggest viewing related comments
-            if (comment.taskId) {
-                nextSteps.push(`Use ${ToolNames.FIND_COMMENTS} with taskId=${comment.taskId} to see all task comments`);
-            }
-            else if (comment.projectId) {
-                nextSteps.push(`Use ${ToolNames.FIND_COMMENTS} with projectId=${comment.projectId} to see all project comments`);
-            }
-        }
-    }
-    else {
-        // Multiple comments
-        nextSteps.push(`Use ${ADD_COMMENTS} with ${searchType}Id=${searchId} to add new comment`);
-        if (comments.length > 0) {
-            nextSteps.push(`Use ${ToolNames.FIND_COMMENTS} with commentId to view specific comment details`);
-        }
-        // Pagination
-        if (hasMore && nextCursor) {
-            nextSteps.push(`Use ${ToolNames.FIND_COMMENTS} with cursor="${nextCursor}" to get more results`);
-        }
-    }
-    const next = formatNextSteps(nextSteps);
-    return `${summary}\n${next}`;
-}
-export { findComments };

package/dist/tools/find-completed-tasks.js

@@ -1,161 +0,0 @@
-import { z } from 'zod';
-import { appendToQuery, resolveResponsibleUser } from '../filter-helpers.js';
-import { getToolOutput } from '../mcp-helpers.js';
-import { mapTask } from '../tool-helpers.js';
-import { ApiLimits } from '../utils/constants.js';
-import { generateLabelsFilter, LabelsSchema } from '../utils/labels.js';
-import { previewTasks, summarizeList } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { FIND_TASKS_BY_DATE, GET_OVERVIEW } = ToolNames;
-const ArgsSchema = {
-    getBy: z
-        .enum(['completion', 'due'])
-        .default('completion')
-        .describe('The method to use to get the tasks: "completion" to get tasks by completion date (ie, when the task was actually completed), "due" to get tasks by due date (ie, when the task was due to be completed by).'),
-    since: z
-        .string()
-        .date()
-        .regex(/^\d{4}-\d{2}-\d{2}$/)
-        .describe('The start date to get the tasks for. Format: YYYY-MM-DD.'),
-    until: z
-        .string()
-        .date()
-        .regex(/^\d{4}-\d{2}-\d{2}$/)
-        .describe('The start date to get the tasks for. Format: YYYY-MM-DD.'),
-    workspaceId: z.string().optional().describe('The ID of the workspace to get the tasks for.'),
-    projectId: z.string().optional().describe('The ID of the project to get the tasks for.'),
-    sectionId: z.string().optional().describe('The ID of the section to get the tasks for.'),
-    parentId: z.string().optional().describe('The ID of the parent task to get the tasks for.'),
-    responsibleUser: z
-        .string()
-        .optional()
-        .describe('Find tasks assigned to this user. Can be a user ID, name, or email address. Defaults to all collaborators when omitted.'),
-    limit: z
-        .number()
-        .int()
-        .min(1)
-        .max(ApiLimits.COMPLETED_TASKS_MAX)
-        .default(ApiLimits.COMPLETED_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).'),
-    ...LabelsSchema,
-};
-const findCompletedTasks = {
-    name: ToolNames.FIND_COMPLETED_TASKS,
-    description: 'Get completed tasks (includes all collaborators by default—use responsibleUser to narrow).',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { getBy, labels, labelsOperator, since, until, responsibleUser, ...rest } = args;
-        // Resolve assignee name to user ID if provided
-        const resolved = await resolveResponsibleUser(client, responsibleUser);
-        const assigneeEmail = resolved?.email;
-        // Build combined filter query (labels + assignment)
-        const labelsFilter = generateLabelsFilter(labels, labelsOperator);
-        let filterQuery = labelsFilter;
-        if (resolved && assigneeEmail) {
-            filterQuery = appendToQuery(filterQuery, `assigned to: ${assigneeEmail}`);
-        }
-        // Get user timezone to convert local dates to UTC
-        const user = await client.getUser();
-        const userGmtOffset = user.tzInfo?.gmtString || '+00:00';
-        // Convert user's local date to UTC timestamps
-        // This ensures we capture the entire day from the user's perspective
-        const sinceWithOffset = `${since}T00:00:00${userGmtOffset}`;
-        const untilWithOffset = `${until}T23:59:59${userGmtOffset}`;
-        // Parse and convert to UTC
-        const sinceDateTime = new Date(sinceWithOffset).toISOString();
-        const untilDateTime = new Date(untilWithOffset).toISOString();
-        const { items, nextCursor } = getBy === 'completion'
-            ? await client.getCompletedTasksByCompletionDate({
-                ...rest,
-                since: sinceDateTime,
-                until: untilDateTime,
-                ...(filterQuery ? { filterQuery, filterLang: 'en' } : {}),
-            })
-            : await client.getCompletedTasksByDueDate({
-                ...rest,
-                since: sinceDateTime,
-                until: untilDateTime,
-                ...(filterQuery ? { filterQuery, filterLang: 'en' } : {}),
-            });
-        const mappedTasks = items.map(mapTask);
-        const textContent = generateTextContent({
-            tasks: mappedTasks,
-            args,
-            nextCursor,
-            assigneeEmail,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                tasks: mappedTasks,
-                nextCursor,
-                totalCount: mappedTasks.length,
-                hasMore: Boolean(nextCursor),
-                appliedFilters: args,
-            },
-        });
-    },
-};
-function generateTextContent({ tasks, args, nextCursor, assigneeEmail, }) {
-    // Generate subject description
-    const getByText = args.getBy === 'completion' ? 'completed' : 'due';
-    const subject = `Completed tasks (by ${getByText} date)`;
-    // Generate filter hints
-    const filterHints = [];
-    filterHints.push(`${getByText} date: ${args.since} to ${args.until}`);
-    if (args.projectId)
-        filterHints.push(`project: ${args.projectId}`);
-    if (args.sectionId)
-        filterHints.push(`section: ${args.sectionId}`);
-    if (args.parentId)
-        filterHints.push(`parent: ${args.parentId}`);
-    if (args.workspaceId)
-        filterHints.push(`workspace: ${args.workspaceId}`);
-    // Add label filter information
-    if (args.labels && args.labels.length > 0) {
-        const labelText = args.labels
-            .map((label) => `@${label}`)
-            .join(args.labelsOperator === 'and' ? ' & ' : ' | ');
-        filterHints.push(`labels: ${labelText}`);
-    }
-    // Add responsible user filter information
-    if (args.responsibleUser) {
-        const email = assigneeEmail || args.responsibleUser;
-        filterHints.push(`assigned to: ${email}`);
-    }
-    // Generate helpful suggestions for empty results
-    const zeroReasonHints = [];
-    if (tasks.length === 0) {
-        zeroReasonHints.push('No tasks completed in this date range');
-        zeroReasonHints.push('Try expanding the date range');
-        if (args.projectId || args.sectionId || args.parentId) {
-            zeroReasonHints.push('Try removing project/section/parent filters');
-        }
-        if (args.getBy === 'due') {
-            zeroReasonHints.push('Try switching to "completion" date instead');
-        }
-    }
-    // Generate contextual next steps
-    const nextSteps = [];
-    if (tasks.length > 0) {
-        nextSteps.push(`Use ${FIND_TASKS_BY_DATE} for active tasks or ${GET_OVERVIEW} for current productivity.`);
-        if (tasks.some((task) => task.recurring)) {
-            nextSteps.push('Recurring tasks will automatically create new instances.');
-        }
-    }
-    return summarizeList({
-        subject,
-        count: tasks.length,
-        limit: args.limit,
-        nextCursor: nextCursor ?? undefined,
-        filterHints,
-        previewLines: previewTasks(tasks, Math.min(tasks.length, args.limit)),
-        zeroReasonHints,
-        nextSteps,
-    });
-}
-export { findCompletedTasks };