@plandesk/api 0.7.0 → 0.9.0

package/dist/events.d.ts

@@ -24,6 +24,20 @@ export type CommentUpdatedEvent = {
     documentId: string;
     projectId: string;
 };
+export type FolderCreatedEvent = {
+    type: 'folder_created';
+    folderId: string;
+    projectId: string;
+};
+export type FolderUpdatedEvent = {
+    type: 'folder_updated';
+    folderId: string;
+    projectId: string;
+};
+export type TagUpdatedEvent = {
+    type: 'tag_updated';
+    projectId: string;
+};
 export type NoteCreatedEvent = {
     type: 'note_created';
     noteId: string;
@@ -53,7 +67,12 @@ export type SubmissionsPulledEvent = {
     type: 'submissions_pulled';
     projectId: string;
 };
-export type PlankDeskEvent = TaskUpdatedEvent | CanvasUpdatedEvent | DocumentCreatedEvent | CommentCreatedEvent | CommentUpdatedEvent | NoteCreatedEvent | NoteUpdatedEvent | AgentRunStartedEvent | AgentRunProgressEvent | AgentRunCompletedEvent | SubmissionsPulledEvent;
+export type GoalUpdatedEvent = {
+    type: 'goal_updated';
+    goalId: string;
+    projectId: string;
+};
+export type PlankDeskEvent = TaskUpdatedEvent | TagUpdatedEvent | CanvasUpdatedEvent | DocumentCreatedEvent | CommentCreatedEvent | CommentUpdatedEvent | FolderCreatedEvent | FolderUpdatedEvent | NoteCreatedEvent | NoteUpdatedEvent | AgentRunStartedEvent | AgentRunProgressEvent | AgentRunCompletedEvent | SubmissionsPulledEvent | GoalUpdatedEvent;
 export type EventListener = (event: PlankDeskEvent) => void;
 export type EventBus = {
     subscribe(listener: EventListener): () => void;

package/dist/index.d.ts

@@ -5,19 +5,26 @@ export { mountStatic } from './static.js';
 export { createServices, type Services, type ServicesDeps } from './services/index.js';
 export { createEventBus, type EventBus, type PlankDeskEvent } from './events.js';
 export type { ProjectService } from './services/projects.js';
+export type { GoalService, VerificationEvidence } from './services/goals.js';
+export { GoalCompletionBlockedError, GoalVerificationRequiredError, InvalidGoalTransitionError, InvalidVerificationSurfaceError, } from './services/goals.js';
 export type { TaskService } from './services/tasks.js';
+export { InvalidGoalReferenceError } from './services/tasks.js';
+export type { TagService } from './services/tags.js';
 export type { CanvasService } from './services/canvas.js';
 export type { DocumentService } from './services/documents.js';
+export type { FolderService } from './services/folders.js';
 export type { NoteService } from './services/notes.js';
 export type { CommentService } from './services/comments.js';
 export type { AgentRunService } from './services/agent-runs.js';
 export { InvalidDocumentError } from './services/documents.js';
+export { InvalidFolderError } from './services/folders.js';
 export { InvalidNoteError } from './services/notes.js';
+export { InvalidTagError } from './services/tags.js';
 export { InvalidCommentError } from './services/comments.js';
 export { InvalidCanvasError } from './services/canvas.js';
 export { InvalidAgentRunError } from './services/agent-runs.js';
 export { InvalidScaffoldError } from './services/projects.js';
 export { InvalidShareError } from './services/share.js';
-export { InvalidTriageError, SyncUnavailableError, SyncUnauthorizedError, type SyncRemote, type SyncService, } from './services/sync.js';
+export { InvalidTriageError, InvalidTriageInputError, SyncUnavailableError, SyncUnauthorizedError, type SyncRemote, type SyncService, } from './services/sync.js';
 export declare const version: () => string;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,14 +4,18 @@ export { healthRouter } from './routes/health.js';
 export { mountStatic } from './static.js';
 export { createServices } from './services/index.js';
 export { createEventBus } from './events.js';
+export { GoalCompletionBlockedError, GoalVerificationRequiredError, InvalidGoalTransitionError, InvalidVerificationSurfaceError, } from './services/goals.js';
+export { InvalidGoalReferenceError } from './services/tasks.js';
 export { InvalidDocumentError } from './services/documents.js';
+export { InvalidFolderError } from './services/folders.js';
 export { InvalidNoteError } from './services/notes.js';
+export { InvalidTagError } from './services/tags.js';
 export { InvalidCommentError } from './services/comments.js';
 export { InvalidCanvasError } from './services/canvas.js';
 export { InvalidAgentRunError } from './services/agent-runs.js';
 export { InvalidScaffoldError } from './services/projects.js';
 export { InvalidShareError } from './services/share.js';
-export { InvalidTriageError, SyncUnavailableError, SyncUnauthorizedError, } from './services/sync.js';
+export { InvalidTriageError, InvalidTriageInputError, SyncUnavailableError, SyncUnauthorizedError, } from './services/sync.js';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';

package/dist/routes/agent-runs.d.ts

@@ -1,4 +1,4 @@
 import { Hono } from 'hono';
-import type { AgentRunService } from '../services/agent-runs.js';
+import { type AgentRunService } from '../services/agent-runs.js';
 export declare function createAgentRunsRouter(agentRunService: AgentRunService): Hono;
 //# sourceMappingURL=agent-runs.d.ts.map

package/dist/routes/agent-runs.js

@@ -1,4 +1,5 @@
 import { Hono } from 'hono';
+import { InvalidAgentRunError } from '../services/agent-runs.js';
 import { parsePaginationParams } from '../serialize.js';
 export function createAgentRunsRouter(agentRunService) {
     const router = new Hono();
@@ -13,6 +14,25 @@ export function createAgentRunsRouter(agentRunService) {
         }
         return c.json(runs);
     });
+    router.post('/agent-runs/:id/progress', async (c) => {
+        const body = await c.req.json();
+        if (typeof body.message !== 'string' || body.message.trim() === '') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        try {
+            const event = agentRunService.recordProgress(c.req.param('id'), body.message);
+            if (!event) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(event, 201);
+        }
+        catch (error) {
+            if (error instanceof InvalidAgentRunError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
     return router;
 }
 //# sourceMappingURL=agent-runs.js.map

package/dist/routes/documents.js

@@ -37,6 +37,7 @@ export function createDocumentsRouter(documentService) {
                 body: body.body,
                 statusLine: body.status_line,
                 parentId: body.parent_id,
+                folderId: body.folder_id,
                 linkedTaskId: resolveLinkedTaskId(body),
             });
             if (!document) {
@@ -67,6 +68,7 @@ export function createDocumentsRouter(documentService) {
                 ...(body.body !== undefined ? { body: body.body } : {}),
                 ...(body.status_line !== undefined ? { statusLine: body.status_line } : {}),
                 ...(body.parent_id !== undefined ? { parentId: body.parent_id } : {}),
+                ...(body.folder_id !== undefined ? { folderId: body.folder_id } : {}),
                 ...(linkedTaskId !== undefined ? { linkedTaskId } : {}),
             });
             if (!document) {

package/dist/routes/folders.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import { type FolderService } from '../services/folders.js';
+export declare function createFoldersRouter(folderService: FolderService): Hono;
+//# sourceMappingURL=folders.d.ts.map

package/dist/routes/folders.js

@@ -0,0 +1,69 @@
+import { Hono } from 'hono';
+import { InvalidFolderError } from '../services/folders.js';
+export function createFoldersRouter(folderService) {
+    const router = new Hono();
+    router.get('/projects/:id/folders', (c) => {
+        const folders = folderService.list(c.req.param('id'));
+        if (!folders) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(folders);
+    });
+    router.post('/projects/:id/folders', async (c) => {
+        const body = await c.req.json();
+        if (typeof body.name !== 'string' || body.name.trim() === '') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        try {
+            const folder = folderService.create(c.req.param('id'), {
+                name: body.name,
+                parentFolderId: body.parent_folder_id,
+            });
+            if (!folder) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(folder, 201);
+        }
+        catch (error) {
+            if (error instanceof InvalidFolderError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
+    router.get('/folders/:id', (c) => {
+        const folder = folderService.get(c.req.param('id'));
+        if (!folder) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(folder);
+    });
+    router.patch('/folders/:id', async (c) => {
+        const body = await c.req.json();
+        try {
+            const folder = folderService.update(c.req.param('id'), {
+                ...(body.name !== undefined ? { name: body.name } : {}),
+                ...(body.parent_folder_id !== undefined ? { parentFolderId: body.parent_folder_id } : {}),
+            });
+            if (!folder) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(folder);
+        }
+        catch (error) {
+            if (error instanceof InvalidFolderError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
+    router.delete('/folders/:id', (c) => {
+        const deleted = folderService.delete(c.req.param('id'));
+        if (!deleted) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.body(null, 204);
+    });
+    return router;
+}
+//# sourceMappingURL=folders.js.map

package/dist/routes/goals.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import { type GoalService } from '../services/goals.js';
+export declare function createGoalsRouter(goalService: GoalService): Hono;
+//# sourceMappingURL=goals.d.ts.map

package/dist/routes/goals.js

@@ -0,0 +1,138 @@
+import { Hono } from 'hono';
+import { InvalidGoalStatusError, isGoalStatus } from '@plandesk/db';
+import { GoalCompletionBlockedError, GoalVerificationRequiredError, InvalidGoalTransitionError, InvalidVerificationSurfaceError, } from '../services/goals.js';
+function mapGoalInput(body) {
+    return {
+        ...(body.objective !== undefined ? { objective: body.objective } : {}),
+        ...(body.verification_surface !== undefined
+            ? { verificationSurface: body.verification_surface }
+            : {}),
+        ...(body.constraints !== undefined ? { constraints: body.constraints } : {}),
+        ...(body.boundaries !== undefined ? { boundaries: body.boundaries } : {}),
+        ...(body.iteration_policy !== undefined ? { iterationPolicy: body.iteration_policy } : {}),
+        ...(body.stop_condition !== undefined ? { stopCondition: body.stop_condition } : {}),
+        ...(body.budget !== undefined ? { budget: body.budget } : {}),
+    };
+}
+function handleGoalError(c, error) {
+    if (error instanceof InvalidGoalStatusError || error instanceof InvalidGoalTransitionError) {
+        return c.json({ error: 'invalid_argument' }, 400);
+    }
+    if (error instanceof InvalidVerificationSurfaceError) {
+        return c.json({ error: 'invalid_argument' }, 400);
+    }
+    if (error instanceof GoalVerificationRequiredError) {
+        return c.json({
+            error: 'verification_required',
+            required_kind: error.requiredKind,
+        }, 400);
+    }
+    if (error instanceof GoalCompletionBlockedError) {
+        return c.json({
+            error: 'blocked_by_incomplete_tasks',
+            incomplete_task_ids: error.incompleteTaskIds,
+        }, 400);
+    }
+    throw error;
+}
+export function createGoalsRouter(goalService) {
+    const router = new Hono();
+    router.post('/projects/:id/goals', async (c) => {
+        const body = await c.req.json();
+        if (typeof body.objective !== 'string' || body.objective.trim() === '') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        if (body.status !== undefined && !isGoalStatus(body.status)) {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        try {
+            const goal = goalService.create(c.req.param('id'), {
+                objective: body.objective,
+                ...(body.status !== undefined ? { status: body.status } : {}),
+                ...mapGoalInput(body),
+            });
+            if (!goal) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(goal, 201);
+        }
+        catch (error) {
+            return handleGoalError(c, error);
+        }
+    });
+    router.get('/projects/:id/goals', (c) => {
+        const goals = goalService.listByProject(c.req.param('id'));
+        if (!goals) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(goals);
+    });
+    router.get('/goals/:id', (c) => {
+        const goal = goalService.get(c.req.param('id'));
+        if (!goal) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(goal);
+    });
+    router.patch('/goals/:id', async (c) => {
+        const body = await c.req.json();
+        if (body.objective !== undefined && body.objective.trim() === '') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        try {
+            const goal = goalService.update(c.req.param('id'), mapGoalInput(body));
+            if (!goal) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(goal);
+        }
+        catch (error) {
+            return handleGoalError(c, error);
+        }
+    });
+    router.post('/goals/:id/pause', (c) => {
+        try {
+            const goal = goalService.pause(c.req.param('id'));
+            if (!goal) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(goal);
+        }
+        catch (error) {
+            return handleGoalError(c, error);
+        }
+    });
+    router.post('/goals/:id/resume', (c) => {
+        try {
+            const goal = goalService.resume(c.req.param('id'));
+            if (!goal) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(goal);
+        }
+        catch (error) {
+            return handleGoalError(c, error);
+        }
+    });
+    router.post('/goals/:id/complete', async (c) => {
+        let body = {};
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            // empty body is valid when the goal has no verification_surface
+        }
+        try {
+            const goal = goalService.complete(c.req.param('id'), body.evidence);
+            if (!goal) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(goal);
+        }
+        catch (error) {
+            return handleGoalError(c, error);
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=goals.js.map

package/dist/routes/projects.d.ts

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
 import type { ProjectService } from '../services/projects.js';
-import type { TaskService } from '../services/tasks.js';
+import { type TaskService } from '../services/tasks.js';
 export declare function createProjectsRouter(projectService: ProjectService, taskService: TaskService): Hono;
 //# sourceMappingURL=projects.d.ts.map

package/dist/routes/projects.js

@@ -1,5 +1,8 @@
 import { Hono } from 'hono';
 import { InvalidTaskStatusError, isTaskStatus } from '@plandesk/db';
+import { InvalidGoalReferenceError } from '../services/tasks.js';
+import { InvalidTagError } from '../services/tags.js';
+import { isStringArray } from './tasks.js';
 import { parsePaginationParams } from '../serialize.js';
 export function createProjectsRouter(projectService, taskService) {
     const router = new Hono();
@@ -57,6 +60,9 @@ export function createProjectsRouter(projectService, taskService) {
         if (body.status !== undefined && !isTaskStatus(body.status)) {
             return c.json({ error: 'invalid_argument' }, 400);
         }
+        if (body.tags !== undefined && !isStringArray(body.tags)) {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
         let dueDate;
         if (body.due_date !== undefined && body.due_date !== null) {
             dueDate = new Date(body.due_date);
@@ -76,6 +82,8 @@ export function createProjectsRouter(projectService, taskService) {
                 ...(body.y !== undefined ? { y: body.y } : {}),
                 ...(body.assignee !== undefined ? { assignee: body.assignee } : {}),
                 ...(dueDate !== undefined ? { dueDate } : {}),
+                ...(body.goal_id !== undefined ? { goalId: body.goal_id } : {}),
+                ...(body.tags !== undefined ? { tags: body.tags } : {}),
             });
             if (!task) {
                 return c.json({ error: 'not_found' }, 404);
@@ -83,7 +91,9 @@ export function createProjectsRouter(projectService, taskService) {
             return c.json(task, 201);
         }
         catch (error) {
-            if (error instanceof InvalidTaskStatusError) {
+            if (error instanceof InvalidTaskStatusError ||
+                error instanceof InvalidTagError ||
+                error instanceof InvalidGoalReferenceError) {
                 return c.json({ error: 'invalid_argument' }, 400);
             }
             throw error;
@@ -96,19 +106,29 @@ export function createProjectsRouter(projectService, taskService) {
                 return c.json({ error: 'invalid_argument' }, 400);
             }
             const status = c.req.query('status');
-            const tasks = taskService.listByProject(c.req.param('id'), { status }, pagination);
+            // Repeated ?tag= params filter with OR semantics (task matches if it has
+            // ANY of the given tags).
+            const tags = c.req.queries('tag');
+            const tasks = taskService.listByProject(c.req.param('id'), { status, ...(tags !== undefined && tags.length > 0 ? { tags } : {}) }, pagination);
             if (!tasks) {
                 return c.json({ error: 'not_found' }, 404);
             }
             return c.json(tasks);
         }
         catch (error) {
-            if (error instanceof InvalidTaskStatusError) {
+            if (error instanceof InvalidTaskStatusError || error instanceof InvalidTagError) {
                 return c.json({ error: 'invalid_argument' }, 400);
             }
             throw error;
         }
     });
+    router.get('/projects/:id/next-task', (c) => {
+        const result = taskService.nextActionable(c.req.param('id'));
+        if (!result) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(result);
+    });
     return router;
 }
 //# sourceMappingURL=projects.js.map

package/dist/routes/submissions.d.ts

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { type SyncService } from '../services/sync.js';
+import type { ProjectService } from '../services/projects.js';
+export declare function createSubmissionsRouter(syncService: SyncService, projectService: ProjectService): Hono;
+//# sourceMappingURL=submissions.d.ts.map

package/dist/routes/submissions.js

@@ -0,0 +1,58 @@
+import { Hono } from 'hono';
+import { shareSubmissionStatuses } from '@plandesk/db';
+import { InvalidTriageError, SyncUnauthorizedError, SyncUnavailableError, } from '../services/sync.js';
+function isSubmissionStatus(value) {
+    return shareSubmissionStatuses.includes(value);
+}
+export function createSubmissionsRouter(syncService, projectService) {
+    const router = new Hono();
+    router.get('/projects/:id/submissions', (c) => {
+        const projectId = c.req.param('id');
+        if (!projectService.get(projectId)) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        const statusParam = c.req.query('status') ?? 'pending';
+        if (!isSubmissionStatus(statusParam)) {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        return c.json(syncService.listTriage(projectId, statusParam));
+    });
+    router.post('/submissions/:id/triage', async (c) => {
+        const submissionId = c.req.param('id');
+        const body = await c.req.json();
+        if (body.action !== 'accept' && body.action !== 'reject') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        const submission = syncService.getSubmission(submissionId);
+        if (submission === undefined) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        const remote = syncService.getRemote(submission.project_id);
+        if (remote === undefined) {
+            return c.json({ error: 'not_published' }, 400);
+        }
+        try {
+            // Triage never creates a `todo` task — the scope->todo release is the human's own
+            // board action, enforced in syncService.triage(). A merge (link_task_id) links to
+            // an existing task instead of creating one; the two are mutually exclusive, so
+            // only one is forwarded.
+            const linkTaskId = body.action === 'accept' ? body.link_task_id : undefined;
+            const result = await syncService.triage(submissionId, body.action, remote, body.action === 'accept' && linkTaskId === undefined ? body.as_task : undefined, linkTaskId);
+            return c.json(result);
+        }
+        catch (error) {
+            if (error instanceof InvalidTriageError) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            if (error instanceof SyncUnauthorizedError) {
+                return c.json({ error: 'sync_unauthorized' }, 400);
+            }
+            if (error instanceof SyncUnavailableError) {
+                return c.json({ error: 'sync_unavailable' }, 502);
+            }
+            throw error;
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=submissions.js.map

package/dist/routes/tags.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import { type TagService } from '../services/tags.js';
+export declare function createTagsRouter(tagService: TagService): Hono;
+//# sourceMappingURL=tags.d.ts.map

package/dist/routes/tags.js

@@ -0,0 +1,62 @@
+import { Hono } from 'hono';
+import { InvalidTagError } from '../services/tags.js';
+export function createTagsRouter(tagService) {
+    const router = new Hono();
+    router.get('/projects/:id/tags', (c) => {
+        const tags = tagService.list(c.req.param('id'));
+        if (!tags) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(tags);
+    });
+    router.post('/projects/:id/tags', async (c) => {
+        const body = await c.req.json();
+        if (typeof body.name !== 'string' || body.name.trim() === '') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        try {
+            const tag = tagService.create(c.req.param('id'), {
+                name: body.name,
+                color: body.color,
+            });
+            if (!tag) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(tag, 201);
+        }
+        catch (error) {
+            if (error instanceof InvalidTagError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
+    router.patch('/tags/:id', async (c) => {
+        const body = await c.req.json();
+        try {
+            const tag = tagService.update(c.req.param('id'), {
+                ...(body.name !== undefined ? { name: body.name } : {}),
+                ...(body.color !== undefined ? { color: body.color } : {}),
+            });
+            if (!tag) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(tag);
+        }
+        catch (error) {
+            if (error instanceof InvalidTagError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
+    router.delete('/tags/:id', (c) => {
+        const deleted = tagService.delete(c.req.param('id'));
+        if (!deleted) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.body(null, 204);
+    });
+    return router;
+}
+//# sourceMappingURL=tags.js.map

package/dist/routes/tasks.d.ts

@@ -1,4 +1,5 @@
 import { Hono } from 'hono';
 import type { TaskService } from '../services/tasks.js';
+export declare function isStringArray(value: unknown): value is string[];
 export declare function createTasksRouter(taskService: TaskService): Hono;
 //# sourceMappingURL=tasks.d.ts.map

package/dist/routes/tasks.js

@@ -1,5 +1,9 @@
 import { Hono } from 'hono';
 import { InvalidTaskStatusError, isTaskStatus } from '@plandesk/db';
+import { InvalidTagError } from '../services/tags.js';
+export function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
 export function createTasksRouter(taskService) {
     const router = new Hono();
     router.patch('/tasks/:id', async (c) => {
@@ -7,6 +11,9 @@ export function createTasksRouter(taskService) {
         if (body.status !== undefined && !isTaskStatus(body.status)) {
             return c.json({ error: 'invalid_argument' }, 400);
         }
+        if (body.tags !== undefined && !isStringArray(body.tags)) {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
         try {
             const task = taskService.update(c.req.param('id'), {
                 ...(body.label !== undefined ? { label: body.label } : {}),
@@ -14,6 +21,7 @@ export function createTasksRouter(taskService) {
                 ...(body.description !== undefined ? { description: body.description } : {}),
                 ...(body.x !== undefined ? { x: body.x } : {}),
                 ...(body.y !== undefined ? { y: body.y } : {}),
+                ...(body.tags !== undefined ? { tags: body.tags } : {}),
             });
             if (!task) {
                 return c.json({ error: 'not_found' }, 404);
@@ -21,7 +29,7 @@ export function createTasksRouter(taskService) {
             return c.json(task);
         }
         catch (error) {
-            if (error instanceof InvalidTaskStatusError) {
+            if (error instanceof InvalidTaskStatusError || error instanceof InvalidTagError) {
                 return c.json({ error: 'invalid_argument' }, 400);
             }
             throw error;