thaddeus 1.0.26 → 1.0.28

package/src/utils/tasks.js

@@ -0,0 +1,672 @@
+import { mkdir, readdir, readFile, unlink, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { z } from 'zod/v4';
+import { getIsNonInteractiveSession, getSessionId } from '../bootstrap/state.js';
+import { uniq } from './array.js';
+import { logForDebugging } from './debug.js';
+import { getClaudeConfigHomeDir, getTeamsDir, isEnvTruthy } from './envUtils.js';
+import { errorMessage, getErrnoCode } from './errors.js';
+import { lazySchema } from './lazySchema.js';
+import * as lockfile from './lockfile.js';
+import { logError } from './log.js';
+import { createSignal } from './signal.js';
+import { jsonParse, jsonStringify } from './slowOperations.js';
+import { getTeamName } from './teammate.js';
+import { getTeammateContext } from './teammateContext.js';
+// Listeners for task list updates (used for immediate UI refresh in same process)
+const tasksUpdated = createSignal();
+/**
+ * Team name set by the leader when creating a team.
+ * Used by getTaskListId() so the leader's tasks are stored under the team name
+ * (matching where tmux/iTerm2 teammates look), not under the session ID.
+ */
+let leaderTeamName;
+/**
+ * Sets the leader's team name for task list resolution.
+ * Called by TeamCreateTool when a team is created.
+ */
+export function setLeaderTeamName(teamName) {
+    if (leaderTeamName === teamName)
+        return;
+    leaderTeamName = teamName;
+    // Changing the task list ID is a "tasks updated" event for subscribers —
+    // they're now looking at a different directory.
+    notifyTasksUpdated();
+}
+/**
+ * Clears the leader's team name.
+ * Called when a team is deleted.
+ */
+export function clearLeaderTeamName() {
+    if (leaderTeamName === undefined)
+        return;
+    leaderTeamName = undefined;
+    notifyTasksUpdated();
+}
+/**
+ * Register a listener to be called when tasks are updated in this process.
+ * Returns an unsubscribe function.
+ */
+export const onTasksUpdated = tasksUpdated.subscribe;
+/**
+ * Notify listeners that tasks have been updated.
+ * Called internally after createTask, updateTask, etc.
+ * Wraps emit in try/catch so listener failures never propagate to callers
+ * (task mutations must succeed from the caller's perspective).
+ */
+export function notifyTasksUpdated() {
+    try {
+        tasksUpdated.emit();
+    }
+    catch {
+        // Ignore listener errors — task mutations must not fail due to notification issues
+    }
+}
+export const TASK_STATUSES = ['pending', 'in_progress', 'completed'];
+export const TaskStatusSchema = lazySchema(() => z.enum(['pending', 'in_progress', 'completed']));
+export const TaskSchema = lazySchema(() => z.object({
+    id: z.string(),
+    subject: z.string(),
+    description: z.string(),
+    activeForm: z.string().optional(), // present continuous form for spinner (e.g., "Running tests")
+    owner: z.string().optional(), // agent ID
+    status: TaskStatusSchema(),
+    blocks: z.array(z.string()), // task IDs this task blocks
+    blockedBy: z.array(z.string()), // task IDs that block this task
+    metadata: z.record(z.string(), z.unknown()).optional(), // arbitrary metadata
+}));
+// High water mark file name - stores the maximum task ID ever assigned
+const HIGH_WATER_MARK_FILE = '.highwatermark';
+// Lock options: retry with backoff so concurrent callers (multiple Claudes
+// in a swarm) wait for the lock instead of failing immediately. The sync
+// lockSync API blocked the event loop; the async API needs explicit retries
+// to achieve the same serialization semantics.
+//
+// Budget sized for ~10+ concurrent swarm agents: each critical section does
+// readdir + N×readFile + writeFile (~50-100ms on slow disks), so the last
+// caller in a 10-way race needs ~900ms. retries=30 gives ~2.6s total wait.
+const LOCK_OPTIONS = {
+    retries: {
+        retries: 30,
+        minTimeout: 5,
+        maxTimeout: 100,
+    },
+};
+function getHighWaterMarkPath(taskListId) {
+    return join(getTasksDir(taskListId), HIGH_WATER_MARK_FILE);
+}
+async function readHighWaterMark(taskListId) {
+    const path = getHighWaterMarkPath(taskListId);
+    try {
+        const content = (await readFile(path, 'utf-8')).trim();
+        const value = parseInt(content, 10);
+        return isNaN(value) ? 0 : value;
+    }
+    catch {
+        return 0;
+    }
+}
+async function writeHighWaterMark(taskListId, value) {
+    const path = getHighWaterMarkPath(taskListId);
+    await writeFile(path, String(value));
+}
+export function isTodoV2Enabled() {
+    // Force-enable tasks in non-interactive mode (e.g. SDK users who want Task tools over TodoWrite)
+    if (isEnvTruthy(process.env.THADDEUS_ENABLE_TASKS)) {
+        return true;
+    }
+    return !getIsNonInteractiveSession();
+}
+/**
+ * Resets the task list for a new swarm - clears any existing tasks.
+ * Writes a high water mark file to prevent ID reuse after reset.
+ * Should be called when a new swarm is created to ensure task numbering starts at 1.
+ * Uses file locking to prevent race conditions when multiple Claudes run in parallel.
+ */
+export async function resetTaskList(taskListId) {
+    const dir = getTasksDir(taskListId);
+    const lockPath = await ensureTaskListLockFile(taskListId);
+    let release;
+    try {
+        // Acquire exclusive lock on the task list
+        release = await lockfile.lock(lockPath, LOCK_OPTIONS);
+        // Find the current highest ID and save it to the high water mark file
+        const currentHighest = await findHighestTaskIdFromFiles(taskListId);
+        if (currentHighest > 0) {
+            const existingMark = await readHighWaterMark(taskListId);
+            if (currentHighest > existingMark) {
+                await writeHighWaterMark(taskListId, currentHighest);
+            }
+        }
+        // Delete all task files
+        let files;
+        try {
+            files = await readdir(dir);
+        }
+        catch {
+            files = [];
+        }
+        for (const file of files) {
+            if (file.endsWith('.json') && !file.startsWith('.')) {
+                const filePath = join(dir, file);
+                try {
+                    await unlink(filePath);
+                }
+                catch {
+                    // Ignore errors, file may already be deleted
+                }
+            }
+        }
+        notifyTasksUpdated();
+    }
+    finally {
+        if (release) {
+            await release();
+        }
+    }
+}
+/**
+ * Gets the task list ID based on the current context.
+ * Priority:
+ * 1. THADDEUS_TASK_LIST_ID - explicit task list ID
+ * 2. In-process teammate: leader's team name (so teammates share the leader's task list)
+ * 3. THADDEUS_TEAM_NAME - set when running as a process-based teammate
+ * 4. Leader team name - set when the leader creates a team via TeamCreate
+ * 5. Session ID - fallback for standalone sessions
+ */
+export function getTaskListId() {
+    if (process.env.THADDEUS_TASK_LIST_ID) {
+        return process.env.THADDEUS_TASK_LIST_ID;
+    }
+    // In-process teammates use the leader's team name so they share the same
+    // task list that tmux/iTerm2 teammates also resolve to.
+    const teammateCtx = getTeammateContext();
+    if (teammateCtx) {
+        return teammateCtx.teamName;
+    }
+    return getTeamName() || leaderTeamName || getSessionId();
+}
+/**
+ * Sanitizes a string for safe use in file paths.
+ * Removes path traversal characters and other potentially dangerous characters.
+ * Only allows alphanumeric characters, hyphens, and underscores.
+ */
+export function sanitizePathComponent(input) {
+    return input.replace(/[^a-zA-Z0-9_-]/g, '-');
+}
+export function getTasksDir(taskListId) {
+    return join(getClaudeConfigHomeDir(), 'tasks', sanitizePathComponent(taskListId));
+}
+export function getTaskPath(taskListId, taskId) {
+    return join(getTasksDir(taskListId), `${sanitizePathComponent(taskId)}.json`);
+}
+export async function ensureTasksDir(taskListId) {
+    const dir = getTasksDir(taskListId);
+    try {
+        await mkdir(dir, { recursive: true });
+    }
+    catch {
+        // Directory already exists or creation failed; callers will surface
+        // errors from subsequent operations.
+    }
+}
+/**
+ * Finds the highest task ID from existing task files (not including high water mark).
+ */
+async function findHighestTaskIdFromFiles(taskListId) {
+    const dir = getTasksDir(taskListId);
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch {
+        return 0;
+    }
+    let highest = 0;
+    for (const file of files) {
+        if (!file.endsWith('.json')) {
+            continue;
+        }
+        const taskId = parseInt(file.replace('.json', ''), 10);
+        if (!isNaN(taskId) && taskId > highest) {
+            highest = taskId;
+        }
+    }
+    return highest;
+}
+/**
+ * Finds the highest task ID ever assigned, considering both existing files
+ * and the high water mark (for deleted/reset tasks).
+ */
+async function findHighestTaskId(taskListId) {
+    const [fromFiles, fromMark] = await Promise.all([
+        findHighestTaskIdFromFiles(taskListId),
+        readHighWaterMark(taskListId),
+    ]);
+    return Math.max(fromFiles, fromMark);
+}
+/**
+ * Creates a new task with a unique ID.
+ * Uses file locking to prevent race conditions when multiple processes
+ * create tasks concurrently.
+ */
+export async function createTask(taskListId, taskData) {
+    const lockPath = await ensureTaskListLockFile(taskListId);
+    let release;
+    try {
+        // Acquire exclusive lock on the task list
+        release = await lockfile.lock(lockPath, LOCK_OPTIONS);
+        // Read highest ID from disk while holding the lock
+        const highestId = await findHighestTaskId(taskListId);
+        const id = String(highestId + 1);
+        const task = { id, ...taskData };
+        const path = getTaskPath(taskListId, id);
+        await writeFile(path, jsonStringify(task, null, 2));
+        notifyTasksUpdated();
+        return id;
+    }
+    finally {
+        if (release) {
+            await release();
+        }
+    }
+}
+export async function getTask(taskListId, taskId) {
+    const path = getTaskPath(taskListId, taskId);
+    try {
+        const content = await readFile(path, 'utf-8');
+        const data = jsonParse(content);
+        // TEMPORARY: Migrate old status names for existing sessions (ant-only)
+        if (process.env.USER_TYPE === 'ant') {
+            if (data.status === 'open')
+                data.status = 'pending';
+            else if (data.status === 'resolved')
+                data.status = 'completed';
+            // Migrate development task statuses to in_progress
+            else if (data.status &&
+                ['planning', 'implementing', 'reviewing', 'verifying'].includes(data.status)) {
+                data.status = 'in_progress';
+            }
+        }
+        const parsed = TaskSchema().safeParse(data);
+        if (!parsed.success) {
+            logForDebugging(`[Tasks] Task ${taskId} failed schema validation: ${parsed.error.message}`);
+            return null;
+        }
+        return parsed.data;
+    }
+    catch (e) {
+        const code = getErrnoCode(e);
+        if (code === 'ENOENT') {
+            return null;
+        }
+        logForDebugging(`[Tasks] Failed to read task ${taskId}: ${errorMessage(e)}`);
+        logError(e);
+        return null;
+    }
+}
+// Internal: no lock. Callers already holding a lock on taskPath must use this
+// to avoid deadlock (claimTask, deleteTask cascade, etc.).
+async function updateTaskUnsafe(taskListId, taskId, updates) {
+    const existing = await getTask(taskListId, taskId);
+    if (!existing) {
+        return null;
+    }
+    const updated = { ...existing, ...updates, id: taskId };
+    const path = getTaskPath(taskListId, taskId);
+    await writeFile(path, jsonStringify(updated, null, 2));
+    notifyTasksUpdated();
+    return updated;
+}
+export async function updateTask(taskListId, taskId, updates) {
+    const path = getTaskPath(taskListId, taskId);
+    // Check existence before locking — proper-lockfile throws if the
+    // target file doesn't exist, and we want a clean null result.
+    const taskBeforeLock = await getTask(taskListId, taskId);
+    if (!taskBeforeLock) {
+        return null;
+    }
+    let release;
+    try {
+        release = await lockfile.lock(path, LOCK_OPTIONS);
+        return await updateTaskUnsafe(taskListId, taskId, updates);
+    }
+    finally {
+        await release?.();
+    }
+}
+export async function deleteTask(taskListId, taskId) {
+    const path = getTaskPath(taskListId, taskId);
+    try {
+        // Update high water mark before deleting to prevent ID reuse
+        const numericId = parseInt(taskId, 10);
+        if (!isNaN(numericId)) {
+            const currentMark = await readHighWaterMark(taskListId);
+            if (numericId > currentMark) {
+                await writeHighWaterMark(taskListId, numericId);
+            }
+        }
+        // Delete the task file
+        try {
+            await unlink(path);
+        }
+        catch (e) {
+            const code = getErrnoCode(e);
+            if (code === 'ENOENT') {
+                return false;
+            }
+            throw e;
+        }
+        // Remove references to this task from other tasks
+        const allTasks = await listTasks(taskListId);
+        for (const task of allTasks) {
+            const newBlocks = task.blocks.filter(id => id !== taskId);
+            const newBlockedBy = task.blockedBy.filter(id => id !== taskId);
+            if (newBlocks.length !== task.blocks.length ||
+                newBlockedBy.length !== task.blockedBy.length) {
+                await updateTask(taskListId, task.id, {
+                    blocks: newBlocks,
+                    blockedBy: newBlockedBy,
+                });
+            }
+        }
+        notifyTasksUpdated();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function listTasks(taskListId) {
+    const dir = getTasksDir(taskListId);
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const taskIds = files
+        .filter(f => f.endsWith('.json'))
+        .map(f => f.replace('.json', ''));
+    const results = await Promise.all(taskIds.map(id => getTask(taskListId, id)));
+    return results.filter((t) => t !== null);
+}
+export async function blockTask(taskListId, fromTaskId, toTaskId) {
+    const [fromTask, toTask] = await Promise.all([
+        getTask(taskListId, fromTaskId),
+        getTask(taskListId, toTaskId),
+    ]);
+    if (!fromTask || !toTask) {
+        return false;
+    }
+    // Update source task: A blocks B
+    if (!fromTask.blocks.includes(toTaskId)) {
+        await updateTask(taskListId, fromTaskId, {
+            blocks: [...fromTask.blocks, toTaskId],
+        });
+    }
+    // Update target task: B is blockedBy A
+    if (!toTask.blockedBy.includes(fromTaskId)) {
+        await updateTask(taskListId, toTaskId, {
+            blockedBy: [...toTask.blockedBy, fromTaskId],
+        });
+    }
+    return true;
+}
+/**
+ * Gets the lock file path for a task list (used for list-level locking)
+ */
+function getTaskListLockPath(taskListId) {
+    return join(getTasksDir(taskListId), '.lock');
+}
+/**
+ * Ensures the lock file exists for a task list
+ */
+async function ensureTaskListLockFile(taskListId) {
+    await ensureTasksDir(taskListId);
+    const lockPath = getTaskListLockPath(taskListId);
+    // proper-lockfile requires the target file to exist. Create it with the
+    // 'wx' flag (write-exclusive) so concurrent callers don't both create it,
+    // and the first one to create wins silently.
+    try {
+        await writeFile(lockPath, '', { flag: 'wx' });
+    }
+    catch {
+        // EEXIST or other — file already exists, which is fine.
+    }
+    return lockPath;
+}
+/**
+ * Attempts to claim a task for an agent with file locking to prevent race conditions.
+ * Returns success if the task was claimed, or a reason if it wasn't.
+ *
+ * When checkAgentBusy is true, uses a task-list-level lock to atomically check
+ * if the agent owns any other open tasks before claiming.
+ */
+export async function claimTask(taskListId, taskId, claimantAgentId, options = {}) {
+    const taskPath = getTaskPath(taskListId, taskId);
+    // Check existence before locking — proper-lockfile.lock throws if the
+    // target file doesn't exist, and we want a clean task_not_found result.
+    const taskBeforeLock = await getTask(taskListId, taskId);
+    if (!taskBeforeLock) {
+        return { success: false, reason: 'task_not_found' };
+    }
+    // If we need to check agent busy status, use task-list-level lock
+    // to prevent TOCTOU race conditions
+    if (options.checkAgentBusy) {
+        return claimTaskWithBusyCheck(taskListId, taskId, claimantAgentId);
+    }
+    // Otherwise, use task-level lock (original behavior)
+    let release;
+    try {
+        // Acquire exclusive lock on the task file
+        release = await lockfile.lock(taskPath, LOCK_OPTIONS);
+        // Read current task state
+        const task = await getTask(taskListId, taskId);
+        if (!task) {
+            return { success: false, reason: 'task_not_found' };
+        }
+        // Check if already claimed by another agent
+        if (task.owner && task.owner !== claimantAgentId) {
+            return { success: false, reason: 'already_claimed', task };
+        }
+        // Check if already resolved
+        if (task.status === 'completed') {
+            return { success: false, reason: 'already_resolved', task };
+        }
+        // Check for unresolved blockers (open or in_progress tasks block)
+        const allTasks = await listTasks(taskListId);
+        const unresolvedTaskIds = new Set(allTasks.filter(t => t.status !== 'completed').map(t => t.id));
+        const blockedByTasks = task.blockedBy.filter(id => unresolvedTaskIds.has(id));
+        if (blockedByTasks.length > 0) {
+            return { success: false, reason: 'blocked', task, blockedByTasks };
+        }
+        // Claim the task (already holding taskPath lock — use unsafe variant)
+        const updated = await updateTaskUnsafe(taskListId, taskId, {
+            owner: claimantAgentId,
+        });
+        return { success: true, task: updated };
+    }
+    catch (error) {
+        logForDebugging(`[Tasks] Failed to claim task ${taskId}: ${errorMessage(error)}`);
+        logError(error);
+        return { success: false, reason: 'task_not_found' };
+    }
+    finally {
+        if (release) {
+            await release();
+        }
+    }
+}
+/**
+ * Claims a task with an atomic check for agent busy status.
+ * Uses a task-list-level lock to ensure the busy check and claim are atomic.
+ */
+async function claimTaskWithBusyCheck(taskListId, taskId, claimantAgentId) {
+    const lockPath = await ensureTaskListLockFile(taskListId);
+    let release;
+    try {
+        // Acquire exclusive lock on the task list
+        release = await lockfile.lock(lockPath, LOCK_OPTIONS);
+        // Read all tasks to check agent status and task state atomically
+        const allTasks = await listTasks(taskListId);
+        // Find the task we want to claim
+        const task = allTasks.find(t => t.id === taskId);
+        if (!task) {
+            return { success: false, reason: 'task_not_found' };
+        }
+        // Check if already claimed by another agent
+        if (task.owner && task.owner !== claimantAgentId) {
+            return { success: false, reason: 'already_claimed', task };
+        }
+        // Check if already resolved
+        if (task.status === 'completed') {
+            return { success: false, reason: 'already_resolved', task };
+        }
+        // Check for unresolved blockers (open or in_progress tasks block)
+        const unresolvedTaskIds = new Set(allTasks.filter(t => t.status !== 'completed').map(t => t.id));
+        const blockedByTasks = task.blockedBy.filter(id => unresolvedTaskIds.has(id));
+        if (blockedByTasks.length > 0) {
+            return { success: false, reason: 'blocked', task, blockedByTasks };
+        }
+        // Check if agent is busy with other unresolved tasks
+        const agentOpenTasks = allTasks.filter(t => t.status !== 'completed' &&
+            t.owner === claimantAgentId &&
+            t.id !== taskId);
+        if (agentOpenTasks.length > 0) {
+            return {
+                success: false,
+                reason: 'agent_busy',
+                task,
+                busyWithTasks: agentOpenTasks.map(t => t.id),
+            };
+        }
+        // Claim the task
+        const updated = await updateTask(taskListId, taskId, {
+            owner: claimantAgentId,
+        });
+        return { success: true, task: updated };
+    }
+    catch (error) {
+        logForDebugging(`[Tasks] Failed to claim task ${taskId} with busy check: ${errorMessage(error)}`);
+        logError(error);
+        return { success: false, reason: 'task_not_found' };
+    }
+    finally {
+        if (release) {
+            await release();
+        }
+    }
+}
+/**
+ * Sanitizes a name for use in file paths
+ */
+function sanitizeName(name) {
+    return name.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase();
+}
+/**
+ * Reads team members from the team file
+ */
+async function readTeamMembers(teamName) {
+    const teamsDir = getTeamsDir();
+    const teamFilePath = join(teamsDir, sanitizeName(teamName), 'config.json');
+    try {
+        const content = await readFile(teamFilePath, 'utf-8');
+        const teamFile = jsonParse(content);
+        return {
+            leadAgentId: teamFile.leadAgentId,
+            members: teamFile.members.map(m => ({
+                agentId: m.agentId,
+                name: m.name,
+                agentType: m.agentType,
+            })),
+        };
+    }
+    catch (e) {
+        const code = getErrnoCode(e);
+        if (code === 'ENOENT') {
+            return null;
+        }
+        logForDebugging(`[Tasks] Failed to read team file for ${teamName}: ${errorMessage(e)}`);
+        return null;
+    }
+}
+/**
+ * Gets the status of all agents in a team based on task ownership.
+ * An agent is considered "idle" if they don't own any open tasks.
+ * An agent is considered "busy" if they own at least one open task.
+ *
+ * @param teamName - The name of the team (also used as taskListId)
+ * @returns Array of agent statuses, or null if team not found
+ */
+export async function getAgentStatuses(teamName) {
+    const teamData = await readTeamMembers(teamName);
+    if (!teamData) {
+        return null;
+    }
+    const taskListId = sanitizeName(teamName);
+    const allTasks = await listTasks(taskListId);
+    // Get unresolved tasks grouped by owner (open or in_progress)
+    const unresolvedTasksByOwner = new Map();
+    for (const task of allTasks) {
+        if (task.status !== 'completed' && task.owner) {
+            const existing = unresolvedTasksByOwner.get(task.owner) || [];
+            existing.push(task.id);
+            unresolvedTasksByOwner.set(task.owner, existing);
+        }
+    }
+    // Build status for each agent (leader is already in members)
+    return teamData.members.map(member => {
+        // Check both name (new) and agentId (legacy) for backwards compatibility
+        const tasksByName = unresolvedTasksByOwner.get(member.name) || [];
+        const tasksById = unresolvedTasksByOwner.get(member.agentId) || [];
+        const currentTasks = uniq([...tasksByName, ...tasksById]);
+        return {
+            agentId: member.agentId,
+            name: member.name,
+            agentType: member.agentType,
+            status: currentTasks.length === 0 ? 'idle' : 'busy',
+            currentTasks,
+        };
+    });
+}
+/**
+ * Unassigns all open tasks from a teammate and builds a notification message.
+ * Used when a teammate is killed or gracefully shuts down.
+ *
+ * @param teamName - The team/task list name
+ * @param teammateId - The teammate's agent ID
+ * @param teammateName - The teammate's display name
+ * @param reason - How the teammate exited ('terminated' | 'shutdown')
+ * @returns The unassigned tasks and a formatted notification message
+ */
+export async function unassignTeammateTasks(teamName, teammateId, teammateName, reason) {
+    const tasks = await listTasks(teamName);
+    const unresolvedAssignedTasks = tasks.filter(t => t.status !== 'completed' &&
+        (t.owner === teammateId || t.owner === teammateName));
+    // Unassign each task and reset status to open
+    for (const task of unresolvedAssignedTasks) {
+        await updateTask(teamName, task.id, { owner: undefined, status: 'pending' });
+    }
+    if (unresolvedAssignedTasks.length > 0) {
+        logForDebugging(`[Tasks] Unassigned ${unresolvedAssignedTasks.length} task(s) from ${teammateName}`);
+    }
+    // Build notification message
+    const actionVerb = reason === 'terminated' ? 'was terminated' : 'has shut down';
+    let notificationMessage = `${teammateName} ${actionVerb}.`;
+    if (unresolvedAssignedTasks.length > 0) {
+        const taskList = unresolvedAssignedTasks
+            .map(t => `#${t.id} "${t.subject}"`)
+            .join(', ');
+        notificationMessage += ` ${unresolvedAssignedTasks.length} task(s) were unassigned: ${taskList}. Use TaskList to check availability and TaskUpdate with owner to reassign them to idle teammates.`;
+    }
+    return {
+        unassignedTasks: unresolvedAssignedTasks.map(t => ({
+            id: t.id,
+            subject: t.subject,
+        })),
+        notificationMessage,
+    };
+}
+export const DEFAULT_TASKS_MODE_TASK_LIST_ID = 'tasklist';