tododdle-mcp 2.7.1 → 3.0.0

package/dist/server.js

@@ -186,7 +186,7 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
         [
             'archive_project',
             true,
-            'Archive a project without deleting its tasks. Requires explicit approval.',
+            'Archive a project without deleting its tickets. Requires explicit approval.',
             true,
         ],
         ['restore_project', false, 'Restore an archived project.', false],
@@ -205,8 +205,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             },
         }, async ({ projectId, expectedUpdatedAt }) => toolResult(await api.put(`/api/external/projects/${projectId}`, { archived, expectedUpdatedAt })));
     }
-    server.registerTool('list_plans', {
-        description: 'List bounded active or archived plans in a project.',
+    server.registerTool('list_boards', {
+        description: 'List bounded active or archived boards in a project.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             search: z.string().optional(),
@@ -221,8 +221,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, ...query }) => toolResult(await api.get(`/api/external/projects/${projectId}/plans`, query)));
-    server.registerTool('get_plan', {
-        description: 'Get one plan in a project.',
+    server.registerTool('get_board', {
+        description: 'Get one board in a project.',
         inputSchema: z.object({ projectId: z.string().min(1), planId: z.string().min(1) }),
         annotations: {
             readOnlyHint: true,
@@ -231,8 +231,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, planId }) => toolResult(await api.get(`/api/external/projects/${projectId}/plans/${planId}`)));
-    server.registerTool('create_plan', {
-        description: 'Create a plan in a project.',
+    server.registerTool('create_board', {
+        description: 'Create a board in a project.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             name: z.string().min(1).max(500),
@@ -248,8 +248,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, idempotencyKey, ...body }) => toolResult(await api.post(`/api/external/projects/${projectId}/plans`, body, idempotencyKey)));
-    server.registerTool('update_plan', {
-        description: 'Update plan details using optimistic concurrency.',
+    server.registerTool('update_board', {
+        description: 'Update board details using optimistic concurrency.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             planId: z.string().min(1),
@@ -266,8 +266,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, planId, ...body }) => toolResult(await api.put(`/api/external/projects/${projectId}/plans/${planId}`, body)));
-    server.registerTool('move_plan', {
-        description: 'Reorder a plan within its project using optimistic concurrency.',
+    server.registerTool('move_board', {
+        description: 'Reorder a board within its project using optimistic concurrency.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             planId: z.string().min(1),
@@ -283,12 +283,12 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
     }, async ({ projectId, planId, ...body }) => toolResult(await api.put(`/api/external/projects/${projectId}/plans/${planId}`, body)));
     for (const [name, archived, description, destructiveHint] of [
         [
-            'archive_plan',
+            'archive_board',
             true,
-            'Archive a plan without changing its tasks. Requires explicit approval.',
+            'Archive a board without changing its tickets. Requires explicit approval.',
             true,
         ],
-        ['restore_plan', false, 'Restore an archived plan.', false],
+        ['restore_board', false, 'Restore an archived board.', false],
     ]) {
         server.registerTool(name, {
             description,
@@ -308,8 +308,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             expectedUpdatedAt,
         })));
     }
-    server.registerTool('list_sections', {
-        description: 'List bounded sections and entry automations in a plan.',
+    server.registerTool('list_lanes', {
+        description: 'List bounded lanes and entry automations in a board.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             planId: z.string().min(1),
@@ -325,8 +325,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, planId, ...query }) => toolResult(await api.get(`/api/external/projects/${projectId}/plans/${planId}/sections`, query)));
-    server.registerTool('get_section', {
-        description: 'Get one plan section and its entry automations.',
+    server.registerTool('get_lane', {
+        description: 'Get one board lane and its entry automations.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             planId: z.string().min(1),
@@ -339,8 +339,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, planId, sectionId }) => toolResult(await api.get(`/api/external/projects/${projectId}/plans/${planId}/sections/${sectionId}`)));
-    server.registerTool('create_section', {
-        description: 'Create a section with optional typed entry automations.',
+    server.registerTool('create_lane', {
+        description: 'Create a lane with optional typed entry automations.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             planId: z.string().min(1),
@@ -360,8 +360,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, planId, idempotencyKey, ...body }) => toolResult(await api.post(`/api/external/projects/${projectId}/plans/${planId}/sections`, body, idempotencyKey)));
-    server.registerTool('update_section', {
-        description: 'Update a section and its entry automations using optimistic concurrency.',
+    server.registerTool('update_lane', {
+        description: 'Update a lane and its entry automations using optimistic concurrency.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             planId: z.string().min(1),
@@ -382,8 +382,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, planId, sectionId, ...body }) => toolResult(await api.put(`/api/external/projects/${projectId}/plans/${planId}/sections/${sectionId}`, body)));
-    server.registerTool('move_section', {
-        description: 'Reorder a section within its plan using optimistic concurrency.',
+    server.registerTool('move_lane', {
+        description: 'Reorder a lane within its board using optimistic concurrency.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             planId: z.string().min(1),
@@ -400,12 +400,12 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
     }, async ({ projectId, planId, sectionId, ...body }) => toolResult(await api.put(`/api/external/projects/${projectId}/plans/${planId}/sections/${sectionId}`, body)));
     for (const [name, archived, description, destructiveHint] of [
         [
-            'archive_section',
+            'archive_lane',
             true,
-            'Archive a section without changing its tasks. Requires explicit approval.',
+            'Archive a lane without changing its tickets. Requires explicit approval.',
             true,
         ],
-        ['restore_section', false, 'Restore an archived section.', false],
+        ['restore_lane', false, 'Restore an archived lane.', false],
     ]) {
         server.registerTool(name, {
             description,
@@ -540,7 +540,7 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
         },
     }, async ({ noteId, expectedUpdatedAt }) => toolResult(await api.delete(`/api/external/notes/${noteId}`, { expectedUpdatedAt })));
     server.registerTool('get_project_context', {
-        description: 'Get bounded project-plan and section context for task planning.',
+        description: 'Get bounded board and lane context for ticket planning.',
         inputSchema: z.object({ projectId: z.string().min(1) }),
         annotations: {
             readOnlyHint: true,
@@ -559,8 +559,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: true,
         },
     }, async (input) => toolResult(await uploadDocument(api, options, input)));
-    server.registerTool('attach_file_to_task', {
-        description: 'Upload an approved local file or HTTPS URL and attach it to a task in the same project.',
+    server.registerTool('attach_file_to_ticket', {
+        description: 'Upload an approved local file or HTTPS URL and attach it to a ticket in the same project.',
         inputSchema: taskUploadInputSchema,
         annotations: {
             readOnlyHint: false,
@@ -586,8 +586,43 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async (input) => toolResult(await api.get('/api/external/work-queue', input)));
+    server.registerTool('list_available_work', {
+        description: 'List bounded, unblocked, currently unclaimed tickets eligible for an Agent Connection in one project, ordered by priority, due date, and project position.',
+        inputSchema: z.object({
+            projectId: z.string().min(1),
+            status: z.enum(['TODO', 'IN_PROGRESS']).default('TODO'),
+            priority: prioritySchema.optional(),
+            search: z.string().optional(),
+            page: z.number().int().min(1).default(1),
+            limit: z.number().int().min(1).max(100).default(50),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (input) => toolResult(await api.get('/api/external/work-queue/available', input)));
+    server.registerTool('claim_next_ticket', {
+        description: 'Atomically claim the highest-ranked eligible ticket in one project. Reuse a unique stable runId to replay the same live claim safely.',
+        inputSchema: z.object({
+            projectId: z.string().min(1),
+            runId: z.string().min(1).max(200),
+            status: z.enum(['TODO', 'IN_PROGRESS']).default('TODO'),
+            priority: prioritySchema.optional(),
+            search: z.string().optional(),
+            state: z.enum(['ACTIVE', 'WAITING']).default('ACTIVE'),
+            leaseSeconds: z.number().int().min(60).max(3600).default(900),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (body) => toolResult(await api.post('/api/external/work-queue/available', body)));
     server.registerTool('get_focus_list', {
-        description: 'List the current user’s deliberately curated Focus tasks.',
+        description: 'List the current user’s deliberately curated Focus tickets.',
         inputSchema: z.object({
             projectId: z.string().optional(),
             status: statusSchema.optional(),
@@ -603,8 +638,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async (input) => toolResult(await api.get('/api/external/focus', input)));
-    server.registerTool('add_task_to_focus', {
-        description: 'Add an accessible active task to Focus. Repeated additions are idempotent.',
+    server.registerTool('add_ticket_to_focus', {
+        description: 'Add an accessible active ticket to Focus. Repeated additions are idempotent.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             bucket: focusBucketSchema.default('NEXT'),
@@ -617,8 +652,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ idempotencyKey, ...body }) => toolResult(await api.post('/api/external/focus', body, idempotencyKey || randomUUID())));
-    server.registerTool('move_focus_task', {
-        description: 'Move or reorder a Focus task using optimistic concurrency.',
+    server.registerTool('move_focus_ticket', {
+        description: 'Move or reorder a Focus ticket using optimistic concurrency.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             bucket: focusBucketSchema,
@@ -632,8 +667,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId, ...body }) => toolResult(await api.patch(`/api/external/focus/${taskId}`, body)));
-    server.registerTool('remove_task_from_focus', {
-        description: 'Remove personal Focus metadata without changing the underlying task.',
+    server.registerTool('remove_ticket_from_focus', {
+        description: 'Remove personal Focus metadata without changing the underlying ticket.',
         inputSchema: z.object({ taskId: z.string().min(1) }),
         annotations: {
             readOnlyHint: false,
@@ -642,8 +677,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId }) => toolResult(await api.delete(`/api/external/focus/${taskId}`, {})));
-    server.registerTool('list_tasks', {
-        description: 'List bounded tasks with optional project, plan, section, assignee, status, priority, search, and archive filters.',
+    server.registerTool('list_tickets', {
+        description: 'List bounded tickets with optional project, board, lane, assignee, status, priority, search, and archive filters. The stable planId and sectionId fields identify the board and lane.',
         inputSchema: z.object({
             projectId: z.string().min(1).optional(),
             planId: z.string().min(1).optional(),
@@ -663,8 +698,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async (input) => toolResult(await api.get('/api/external/tasks', input)));
-    server.registerTool('get_task', {
-        description: 'Get complete task context including comments and blocker information.',
+    server.registerTool('get_ticket', {
+        description: 'Get complete ticket context including comments and blocker information.',
         inputSchema: z.object({ taskId: z.string().min(1) }),
         annotations: {
             readOnlyHint: true,
@@ -673,8 +708,23 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId }) => toolResult(await api.get(`/api/external/tasks/${taskId}`)));
-    server.registerTool('claim_task', {
-        description: 'Claim or refresh a task for the current Agent Connection without changing its human assignee. Reuse a stable runId and refresh before the lease expires.',
+    server.registerTool('claim_ticket', {
+        description: 'Claim or refresh a ticket for the current Agent Connection without changing its human assignee. Reuse a stable runId and refresh before the lease expires.',
+        inputSchema: z.object({
+            taskId: z.string().min(1),
+            runId: z.string().min(1).max(200),
+            state: z.enum(['ACTIVE', 'WAITING']).default('ACTIVE'),
+            leaseSeconds: z.number().int().min(60).max(3600).default(900),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async ({ taskId, ...body }) => toolResult(await api.put(`/api/external/tasks/${taskId}/claim`, body)));
+    server.registerTool('renew_ticket_claim', {
+        description: 'Renew the current Agent Connection lease for a specific ticket and stable runId before it expires.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             runId: z.string().min(1).max(200),
@@ -688,8 +738,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId, ...body }) => toolResult(await api.put(`/api/external/tasks/${taskId}/claim`, body)));
-    server.registerTool('release_task', {
-        description: 'Release the current Agent Connection work claim without changing task status or human assignment.',
+    server.registerTool('release_ticket', {
+        description: 'Release the current Agent Connection work claim without changing ticket status or human assignment.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             runId: z.string().min(1).max(200),
@@ -701,8 +751,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId, ...body }) => toolResult(await api.delete(`/api/external/tasks/${taskId}/claim`, body)));
-    server.registerTool('create_task', {
-        description: 'Create a task in an active project plan section.',
+    server.registerTool('create_ticket', {
+        description: 'Create a ticket in an active board lane. The stable planId and sectionId fields identify the board and lane.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             planId: z.string().min(1),
@@ -724,8 +774,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ idempotencyKey, ...body }) => toolResult(await api.post('/api/external/tasks', body, idempotencyKey || randomUUID())));
-    server.registerTool('update_task', {
-        description: 'Update editable task fields. Requires the latest updatedAt value to prevent overwriting newer changes.',
+    server.registerTool('update_ticket', {
+        description: 'Update editable ticket fields. Requires the latest updatedAt value to prevent overwriting newer changes.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             expectedUpdatedAt: expectedUpdatedAtSchema,
@@ -744,8 +794,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId, ...body }) => toolResult(await api.put(`/api/external/tasks/${taskId}`, body)));
-    server.registerTool('transition_task', {
-        description: 'Transition a task to a canonical status.',
+    server.registerTool('transition_ticket', {
+        description: 'Transition a ticket to a canonical status.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             status: statusSchema,
@@ -758,8 +808,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId, ...body }) => toolResult(await api.put(`/api/external/tasks/${taskId}`, body)));
-    server.registerTool('move_task', {
-        description: 'Move a task to an active section, optionally in another plan in the same project. Preview first because section actions may archive the task.',
+    server.registerTool('move_ticket', {
+        description: 'Move a ticket to an active lane, optionally on another board in the same project. Preview first because lane actions may archive the ticket.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             planId: z.string().min(1).optional(),
@@ -774,8 +824,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId, ...body }) => toolResult(await api.put(`/api/external/tasks/${taskId}/move`, body)));
-    server.registerTool('preview_task_move', {
-        description: 'Preview destination section actions, warnings, destructive effects, and hierarchy blockers before moving a task.',
+    server.registerTool('preview_ticket_move', {
+        description: 'Preview destination lane actions, warnings, destructive effects, and hierarchy blockers before moving a ticket.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             planId: z.string().min(1).optional(),
@@ -789,8 +839,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId, ...body }) => toolResult(await api.post(`/api/external/tasks/${taskId}/move/preview`, body)));
-    server.registerTool('set_task_blocker', {
-        description: 'Set or clear the active same-project task blocking this task.',
+    server.registerTool('set_ticket_blocker', {
+        description: 'Set or clear the active same-project ticket blocking this ticket.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             blockedByTaskId: z.string().nullable(),
@@ -803,8 +853,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ taskId, ...body }) => toolResult(await api.put(`/api/external/tasks/${taskId}`, body)));
-    server.registerTool('add_task_comment', {
-        description: 'Add an implementation note, finding, decision, or completion evidence to a task.',
+    server.registerTool('add_ticket_comment', {
+        description: 'Add an implementation note, finding, decision, or completion evidence to a ticket.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             content: z.string().min(1),
@@ -843,8 +893,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ commentId }) => toolResult(await api.post(`/api/external/agent-inbox/${commentId}/acknowledge`, {})));
-    server.registerTool('archive_task', {
-        description: 'Archive a task and clear dependent blocker relationships. Requires explicit human approval.',
+    server.registerTool('archive_ticket', {
+        description: 'Archive a ticket and clear dependent blocker relationships. Requires explicit human approval.',
         inputSchema: z.object({
             taskId: z.string().min(1),
             expectedUpdatedAt: expectedUpdatedAtSchema,
@@ -889,8 +939,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, ...query }) => toolResult(await api.get(`/api/external/projects/${projectId}/time-entries`, query)));
-    server.registerTool('list_task_time', {
-        description: 'List bounded time entries and totals for one task.',
+    server.registerTool('list_ticket_time', {
+        description: 'List bounded time entries and totals for one ticket.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             taskId: z.string().min(1),
@@ -904,8 +954,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, taskId, ...query }) => toolResult(await api.get(`/api/external/projects/${projectId}/tasks/${taskId}/time-entries`, query)));
-    server.registerTool('start_task_timer', {
-        description: 'Start a live timer on an active task. A task allows one active timer; different tasks may run concurrently.',
+    server.registerTool('start_ticket_timer', {
+        description: 'Start a live timer on an active ticket. A ticket allows one active timer; different tickets may run concurrently.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             taskId: z.string().min(1),
@@ -921,8 +971,8 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, taskId, idempotencyKey, startedAt, ...body }) => toolResult(await api.post(`/api/external/projects/${projectId}/tasks/${taskId}/time-entries`, { ...body, startedAt: startedAt ?? new Date().toISOString() }, idempotencyKey || randomUUID())));
-    server.registerTool('stop_task_timer', {
-        description: 'Stop an active task timer using optimistic concurrency.',
+    server.registerTool('stop_ticket_timer', {
+        description: 'Stop an active ticket timer using optimistic concurrency.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             taskId: z.string().min(1),
@@ -936,9 +986,9 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             idempotentHint: true,
             openWorldHint: false,
         },
-    }, async ({ projectId, taskId, timeEntryId, endedAt, expectedUpdatedAt }) => toolResult(await api.post(`/api/external/projects/${projectId}/tasks/${taskId}/time-entries/${timeEntryId}/stop`, { endedAt: endedAt ?? new Date().toISOString(), expectedUpdatedAt })));
-    server.registerTool('log_task_time', {
-        description: 'Log a completed historical interval against a task.',
+    }, async ({ projectId, taskId, timeEntryId, endedAt, expectedUpdatedAt }) => toolResult(await api.post(`/api/external/projects/${projectId}/tasks/${taskId}/time-entries/${timeEntryId}/stop`, { ...(endedAt ? { endedAt } : {}), expectedUpdatedAt })));
+    server.registerTool('log_ticket_time', {
+        description: 'Log a completed historical interval against a ticket.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             taskId: z.string().min(1),
@@ -990,7 +1040,7 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
         },
     }, async ({ projectId, taskId, timeEntryId, expectedUpdatedAt }) => toolResult(await api.delete(`/api/external/projects/${projectId}/tasks/${taskId}/time-entries/${timeEntryId}`, { expectedUpdatedAt })));
     server.registerTool('get_project_brief', {
-        description: 'Read the canonical project brief before planning or changing work.',
+        description: 'Read the canonical project brief before planning or changing tickets.',
         inputSchema: z.object({ projectId: z.string().min(1) }),
         annotations: {
             readOnlyHint: true,
@@ -1017,7 +1067,7 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
         },
     }, async ({ projectId, ...query }) => toolResult(await api.get(`/api/external/projects/${projectId}/artifacts`, query)));
     server.registerTool('get_project_artifact', {
-        description: 'Get complete Markdown, relationships, comments, and task links for one project artifact.',
+        description: 'Get complete Markdown, relationships, comments, and ticket links for one project artifact.',
         inputSchema: z.object({ projectId: z.string().min(1), artifactId: z.string().min(1) }),
         annotations: {
             readOnlyHint: true,
@@ -1108,7 +1158,7 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, artifactId, ...body }) => toolResult(await api.post(`/api/external/projects/${projectId}/artifacts/${artifactId}/transition`, body)));
-    server.registerTool('link_artifact_task', {
+    server.registerTool('link_artifact_ticket', {
         description: 'Link same-project execution work to the context it implements, informs, evidences, or came from.',
         inputSchema: z.object({
             projectId: z.string().min(1),
@@ -1143,22 +1193,22 @@ export function createToDoddleMcpServer(api, serverOptions = {}) {
             openWorldHint: false,
         },
     }, async ({ projectId, artifactId, idempotencyKey, ...body }) => toolResult(await api.post(`/api/external/projects/${projectId}/artifacts/${artifactId}/comments`, body, idempotencyKey || randomUUID())));
-    server.registerResource('task', new ResourceTemplate('tododdle://tasks/{taskId}', { list: undefined }), {
-        title: 'ToDoddle task',
-        description: 'Complete task context by ID.',
+    server.registerResource('ticket', new ResourceTemplate('tododdle://tickets/{ticketId}', { list: undefined }), {
+        title: 'ToDoddle ticket',
+        description: 'Complete ticket context by ID.',
         mimeType: 'application/json',
     }, async (uri, variables) => ({
         contents: [
             {
                 uri: uri.href,
                 mimeType: 'application/json',
-                text: JSON.stringify(await api.get(`/api/external/tasks/${String(variables.taskId)}`), null, 2),
+                text: JSON.stringify(await api.get(`/api/external/tasks/${String(variables.ticketId)}`), null, 2),
             },
         ],
     }));
     server.registerResource('project', new ResourceTemplate('tododdle://projects/{projectId}', { list: undefined }), {
         title: 'ToDoddle project context',
-        description: 'Bounded project-plan and section context by project ID.',
+        description: 'Bounded project board and lane context by project ID.',
         mimeType: 'application/json',
     }, async (uri, variables) => ({
         contents: [