@plandesk/api 0.7.0 → 0.9.0

package/dist/services/goals.d.ts

@@ -0,0 +1,239 @@
+import { type Db, type GoalStatus } from '@plandesk/db';
+import type { EventBus } from '../events.js';
+export type GoalServiceDeps = {
+    db: Db;
+    eventBus: EventBus;
+};
+export declare class InvalidGoalTransitionError extends Error {
+    constructor(message: string);
+}
+export declare class GoalCompletionBlockedError extends Error {
+    incompleteTaskIds: string[];
+    constructor(incompleteTaskIds: string[]);
+}
+export declare class InvalidVerificationSurfaceError extends Error {
+    constructor(message: string);
+}
+export declare class GoalVerificationRequiredError extends Error {
+    requiredKind: VerificationSurfaceKind;
+    constructor(requiredKind: VerificationSurfaceKind);
+}
+export type VerificationSurfaceKind = 'gate_command' | 'acceptance_checklist' | 'human_sign_off';
+export type GateCommandSurface = {
+    kind: 'gate_command';
+    command: string;
+};
+export type AcceptanceChecklistSurface = {
+    kind: 'acceptance_checklist';
+    items: Array<{
+        criterion: string;
+    }>;
+};
+export type HumanSignOffSurface = {
+    kind: 'human_sign_off';
+};
+export type VerificationSurface = GateCommandSurface | AcceptanceChecklistSurface | HumanSignOffSurface;
+export type GateCommandEvidence = {
+    kind: 'gate_command';
+    exit_code: number;
+    command?: string;
+    detail?: string;
+};
+export type AcceptanceChecklistEvidence = {
+    kind: 'acceptance_checklist';
+    checked: string[];
+};
+export type HumanSignOffEvidence = {
+    kind: 'human_sign_off';
+    approved_by: string;
+};
+export type VerificationEvidence = GateCommandEvidence | AcceptanceChecklistEvidence | HumanSignOffEvidence;
+export type LastVerificationRecord = {
+    at: string;
+    green: boolean;
+    kind: VerificationSurfaceKind | null;
+    detail?: string;
+};
+export type CreateGoalInput = {
+    objective: string;
+    verificationSurface?: string | null;
+    constraints?: string | null;
+    boundaries?: string | null;
+    iterationPolicy?: string | null;
+    stopCondition?: string | null;
+    budget?: string | null;
+    status?: GoalStatus;
+};
+export type UpdateGoalInput = {
+    objective?: string;
+    verificationSurface?: string | null;
+    constraints?: string | null;
+    boundaries?: string | null;
+    iterationPolicy?: string | null;
+    stopCondition?: string | null;
+    budget?: string | null;
+};
+export declare function parseVerificationSurface(raw: string | null): VerificationSurface | null;
+export declare function evaluateEvidence(surface: VerificationSurface, evidence: VerificationEvidence): {
+    green: boolean;
+    detail?: string;
+};
+export declare function createGoalService(deps: GoalServiceDeps): {
+    create(projectId: string, input: CreateGoalInput): {
+        id: string;
+        project_id: string;
+        objective: string;
+        status: "active" | "paused" | "complete" | "blocked";
+        verification_surface: string | null;
+        constraints: string | null;
+        boundaries: string | null;
+        iteration_policy: string | null;
+        stop_condition: string | null;
+        budget: string | null;
+        last_verification: {
+            at: string;
+            green: boolean;
+            kind: string | null;
+            detail?: string;
+        } | null;
+        created_at: string;
+        updated_at: string;
+    } | undefined;
+    get(goalId: string): {
+        cycle_tasks: {
+            tags?: import("../serialize.js").SerializedTag[] | undefined;
+            id: string;
+            project_id: string;
+            goal_id: string;
+            label: string;
+            status: "scope" | "todo" | "in_progress" | "done" | "backlog";
+            description: string | null;
+            x: number;
+            y: number;
+            assignee: string | null;
+            due_date: string | null;
+            created_at: string;
+            updated_at: string;
+        }[];
+        id: string;
+        project_id: string;
+        objective: string;
+        status: "active" | "paused" | "complete" | "blocked";
+        verification_surface: string | null;
+        constraints: string | null;
+        boundaries: string | null;
+        iteration_policy: string | null;
+        stop_condition: string | null;
+        budget: string | null;
+        last_verification: {
+            at: string;
+            green: boolean;
+            kind: string | null;
+            detail?: string;
+        } | null;
+        created_at: string;
+        updated_at: string;
+    } | undefined;
+    listByProject(projectId: string): {
+        id: string;
+        project_id: string;
+        objective: string;
+        status: "active" | "paused" | "complete" | "blocked";
+        verification_surface: string | null;
+        constraints: string | null;
+        boundaries: string | null;
+        iteration_policy: string | null;
+        stop_condition: string | null;
+        budget: string | null;
+        last_verification: {
+            at: string;
+            green: boolean;
+            kind: string | null;
+            detail?: string;
+        } | null;
+        created_at: string;
+        updated_at: string;
+    }[] | undefined;
+    update(goalId: string, input: UpdateGoalInput): {
+        id: string;
+        project_id: string;
+        objective: string;
+        status: "active" | "paused" | "complete" | "blocked";
+        verification_surface: string | null;
+        constraints: string | null;
+        boundaries: string | null;
+        iteration_policy: string | null;
+        stop_condition: string | null;
+        budget: string | null;
+        last_verification: {
+            at: string;
+            green: boolean;
+            kind: string | null;
+            detail?: string;
+        } | null;
+        created_at: string;
+        updated_at: string;
+    } | undefined;
+    pause(goalId: string): {
+        id: string;
+        project_id: string;
+        objective: string;
+        status: "active" | "paused" | "complete" | "blocked";
+        verification_surface: string | null;
+        constraints: string | null;
+        boundaries: string | null;
+        iteration_policy: string | null;
+        stop_condition: string | null;
+        budget: string | null;
+        last_verification: {
+            at: string;
+            green: boolean;
+            kind: string | null;
+            detail?: string;
+        } | null;
+        created_at: string;
+        updated_at: string;
+    } | undefined;
+    resume(goalId: string): {
+        id: string;
+        project_id: string;
+        objective: string;
+        status: "active" | "paused" | "complete" | "blocked";
+        verification_surface: string | null;
+        constraints: string | null;
+        boundaries: string | null;
+        iteration_policy: string | null;
+        stop_condition: string | null;
+        budget: string | null;
+        last_verification: {
+            at: string;
+            green: boolean;
+            kind: string | null;
+            detail?: string;
+        } | null;
+        created_at: string;
+        updated_at: string;
+    } | undefined;
+    complete(goalId: string, evidence?: VerificationEvidence): {
+        id: string;
+        project_id: string;
+        objective: string;
+        status: "active" | "paused" | "complete" | "blocked";
+        verification_surface: string | null;
+        constraints: string | null;
+        boundaries: string | null;
+        iteration_policy: string | null;
+        stop_condition: string | null;
+        budget: string | null;
+        last_verification: {
+            at: string;
+            green: boolean;
+            kind: string | null;
+            detail?: string;
+        } | null;
+        created_at: string;
+        updated_at: string;
+    } | undefined;
+};
+export type GoalService = ReturnType<typeof createGoalService>;
+//# sourceMappingURL=goals.d.ts.map

package/dist/services/goals.js

@@ -0,0 +1,323 @@
+import { createGoal, createTask, getGoal, getProject, InvalidGoalStatusError, isGoalStatus, listGoals, listTagsByTaskForProject, listTasks, updateGoal, updateGoalStatus, updateTask, } from '@plandesk/db';
+import { serializeGoal, serializeTask } from '../serialize.js';
+export class InvalidGoalTransitionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidGoalTransitionError';
+    }
+}
+export class GoalCompletionBlockedError extends Error {
+    incompleteTaskIds;
+    constructor(incompleteTaskIds) {
+        super('Goal cannot be completed until all cycle-tasks are done');
+        this.name = 'GoalCompletionBlockedError';
+        this.incompleteTaskIds = incompleteTaskIds;
+    }
+}
+export class InvalidVerificationSurfaceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidVerificationSurfaceError';
+    }
+}
+export class GoalVerificationRequiredError extends Error {
+    requiredKind;
+    constructor(requiredKind) {
+        super(`Verification evidence required for surface kind: ${requiredKind}`);
+        this.name = 'GoalVerificationRequiredError';
+        this.requiredKind = requiredKind;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function parseVerificationSurface(raw) {
+    if (raw === null) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new InvalidVerificationSurfaceError('verification_surface must be valid JSON');
+    }
+    if (!isRecord(parsed) || typeof parsed.kind !== 'string') {
+        throw new InvalidVerificationSurfaceError('verification_surface must include a kind');
+    }
+    switch (parsed.kind) {
+        case 'gate_command': {
+            if (!isNonEmptyString(parsed.command)) {
+                throw new InvalidVerificationSurfaceError('gate_command requires a command');
+            }
+            return { kind: 'gate_command', command: parsed.command };
+        }
+        case 'acceptance_checklist': {
+            if (!Array.isArray(parsed.items) || parsed.items.length === 0) {
+                throw new InvalidVerificationSurfaceError('acceptance_checklist requires non-empty items');
+            }
+            const items = [];
+            for (const item of parsed.items) {
+                if (!isRecord(item) || !isNonEmptyString(item.criterion)) {
+                    throw new InvalidVerificationSurfaceError('acceptance_checklist items require a criterion');
+                }
+                items.push({ criterion: item.criterion });
+            }
+            return { kind: 'acceptance_checklist', items };
+        }
+        case 'human_sign_off':
+            return { kind: 'human_sign_off' };
+        default:
+            throw new InvalidVerificationSurfaceError(`Unknown verification_surface kind: ${parsed.kind}`);
+    }
+}
+export function evaluateEvidence(surface, evidence) {
+    if (surface.kind !== evidence.kind) {
+        return { green: false, detail: `Expected evidence kind ${surface.kind}` };
+    }
+    if (surface.kind === 'gate_command' && evidence.kind === 'gate_command') {
+        if (evidence.exit_code === 0) {
+            return { green: true };
+        }
+        const detail = evidence.detail ??
+            `exit_code ${String(evidence.exit_code)}${evidence.command ? ` for \`${evidence.command}\`` : ''}`;
+        return { green: false, detail };
+    }
+    if (surface.kind === 'acceptance_checklist' && evidence.kind === 'acceptance_checklist') {
+        const missing = surface.items
+            .map((item) => item.criterion)
+            .filter((criterion) => !evidence.checked.includes(criterion));
+        if (missing.length === 0) {
+            return { green: true };
+        }
+        return { green: false, detail: `Missing criteria: ${missing.join(', ')}` };
+    }
+    if (surface.kind === 'human_sign_off' && evidence.kind === 'human_sign_off') {
+        if (isNonEmptyString(evidence.approved_by)) {
+            return { green: true };
+        }
+        return { green: false, detail: 'approved_by is required' };
+    }
+    return { green: false, detail: `Expected evidence kind ${surface.kind}` };
+}
+function validateVerificationSurfaceInput(raw) {
+    if (raw === undefined) {
+        return;
+    }
+    parseVerificationSurface(raw);
+}
+function acceptanceBlockMarker(goalId) {
+    return `Acceptance-block-for: ${goalId}`;
+}
+function hasUnresolvedBlockingTask(db, projectId, goalId) {
+    const marker = acceptanceBlockMarker(goalId);
+    return listTasks(db, projectId).some((task) => task.goalId === goalId && task.status === 'scope' && task.description?.includes(marker));
+}
+// When acceptance finally passes, the remediation task filed on the earlier red
+// result is obsolete — resolve it so a completed goal never shows open work.
+function resolveBlockingTasks(db, projectId, goalId) {
+    const marker = acceptanceBlockMarker(goalId);
+    for (const task of listTasks(db, projectId)) {
+        if (task.goalId === goalId && task.status !== 'done' && task.description?.includes(marker)) {
+            updateTask(db, task.id, { status: 'done' });
+        }
+    }
+}
+function truncateObjective(objective, maxLength = 80) {
+    if (objective.length <= maxLength) {
+        return objective;
+    }
+    return `${objective.slice(0, maxLength - 1)}…`;
+}
+function buildBlockingTaskDescription(goalId, surfaceKind, detail) {
+    const lines = [acceptanceBlockMarker(goalId), '', `Surface kind: ${surfaceKind}`];
+    if (detail) {
+        lines.push(`Detail: ${detail}`);
+    }
+    return lines.join('\n');
+}
+function cycleTasksForGoal(db, projectId, goalId) {
+    const tagsByTask = listTagsByTaskForProject(db, projectId);
+    return listTasks(db, projectId)
+        .filter((task) => task.goalId === goalId)
+        .map((task) => serializeTask(task, tagsByTask.get(task.id) ?? []));
+}
+function emitGoalUpdated(eventBus, goalId, projectId) {
+    eventBus.emit({ type: 'goal_updated', goalId, projectId });
+}
+function recordLastVerification(at, green, kind, detail) {
+    const record = { at, green, kind };
+    if (detail) {
+        record.detail = detail;
+    }
+    return JSON.stringify(record);
+}
+export function createGoalService(deps) {
+    const { db, eventBus } = deps;
+    return {
+        create(projectId, input) {
+            if (input.status !== undefined && !isGoalStatus(input.status)) {
+                throw new InvalidGoalStatusError(input.status);
+            }
+            validateVerificationSurfaceInput(input.verificationSurface);
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            const goal = db.transaction((tx) => createGoal(tx, {
+                projectId,
+                objective: input.objective,
+                status: input.status,
+                verificationSurface: input.verificationSurface,
+                constraints: input.constraints,
+                boundaries: input.boundaries,
+                iterationPolicy: input.iterationPolicy,
+                stopCondition: input.stopCondition,
+                budget: input.budget,
+            }));
+            emitGoalUpdated(eventBus, goal.id, projectId);
+            return serializeGoal(goal);
+        },
+        get(goalId) {
+            const goal = getGoal(db, goalId);
+            if (!goal) {
+                return undefined;
+            }
+            return {
+                ...serializeGoal(goal),
+                cycle_tasks: cycleTasksForGoal(db, goal.projectId, goalId),
+            };
+        },
+        listByProject(projectId) {
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            return listGoals(db, projectId).map(serializeGoal);
+        },
+        update(goalId, input) {
+            const existing = getGoal(db, goalId);
+            if (!existing) {
+                return undefined;
+            }
+            validateVerificationSurfaceInput(input.verificationSurface);
+            const goal = db.transaction((tx) => updateGoal(tx, goalId, input));
+            if (!goal) {
+                return undefined;
+            }
+            emitGoalUpdated(eventBus, goalId, existing.projectId);
+            return serializeGoal(goal);
+        },
+        pause(goalId) {
+            const existing = getGoal(db, goalId);
+            if (!existing) {
+                return undefined;
+            }
+            if (existing.status !== 'active') {
+                throw new InvalidGoalTransitionError('Goal can only be paused from active status');
+            }
+            const goal = db.transaction((tx) => updateGoalStatus(tx, goalId, 'paused'));
+            if (!goal) {
+                return undefined;
+            }
+            emitGoalUpdated(eventBus, goalId, existing.projectId);
+            return serializeGoal(goal);
+        },
+        resume(goalId) {
+            const existing = getGoal(db, goalId);
+            if (!existing) {
+                return undefined;
+            }
+            if (existing.status !== 'paused') {
+                throw new InvalidGoalTransitionError('Goal can only be resumed from paused status');
+            }
+            const goal = db.transaction((tx) => updateGoalStatus(tx, goalId, 'active'));
+            if (!goal) {
+                return undefined;
+            }
+            emitGoalUpdated(eventBus, goalId, existing.projectId);
+            return serializeGoal(goal);
+        },
+        complete(goalId, evidence) {
+            const existing = getGoal(db, goalId);
+            if (!existing) {
+                return undefined;
+            }
+            if (existing.status === 'complete') {
+                throw new InvalidGoalTransitionError('Goal is already complete');
+            }
+            if (existing.status !== 'blocked') {
+                const incomplete = listTasks(db, existing.projectId)
+                    .filter((task) => task.goalId === goalId && task.status !== 'done')
+                    .map((task) => task.id);
+                if (incomplete.length > 0) {
+                    throw new GoalCompletionBlockedError(incomplete);
+                }
+            }
+            const surface = parseVerificationSurface(existing.verificationSurface);
+            const at = new Date().toISOString();
+            if (!surface) {
+                const goal = db.transaction((tx) => updateGoal(tx, goalId, {
+                    status: 'complete',
+                    lastVerification: recordLastVerification(at, true, null),
+                }));
+                if (!goal) {
+                    return undefined;
+                }
+                emitGoalUpdated(eventBus, goalId, existing.projectId);
+                return serializeGoal(goal);
+            }
+            if (!evidence || evidence.kind !== surface.kind) {
+                throw new GoalVerificationRequiredError(surface.kind);
+            }
+            const evaluation = evaluateEvidence(surface, evidence);
+            const lastVerification = recordLastVerification(at, evaluation.green, surface.kind, evaluation.detail);
+            if (evaluation.green) {
+                const goal = db.transaction((tx) => {
+                    const updated = updateGoal(tx, goalId, {
+                        status: 'complete',
+                        lastVerification,
+                    });
+                    if (!updated) {
+                        return undefined;
+                    }
+                    resolveBlockingTasks(tx, existing.projectId, goalId);
+                    return updated;
+                });
+                if (!goal) {
+                    return undefined;
+                }
+                emitGoalUpdated(eventBus, goalId, existing.projectId);
+                return serializeGoal(goal);
+            }
+            const goal = db.transaction((tx) => {
+                const updated = updateGoal(tx, goalId, {
+                    status: 'blocked',
+                    lastVerification,
+                });
+                if (!updated) {
+                    return undefined;
+                }
+                if (!hasUnresolvedBlockingTask(tx, existing.projectId, goalId)) {
+                    createTask(tx, {
+                        projectId: existing.projectId,
+                        goalId,
+                        label: `Fix acceptance failure: ${truncateObjective(existing.objective)}`,
+                        status: 'scope',
+                        description: buildBlockingTaskDescription(goalId, surface.kind, evaluation.detail),
+                    });
+                }
+                return updated;
+            });
+            if (!goal) {
+                return undefined;
+            }
+            emitGoalUpdated(eventBus, goalId, existing.projectId);
+            return serializeGoal(goal);
+        },
+    };
+}
+//# sourceMappingURL=goals.js.map

package/dist/services/index.d.ts

@@ -3,9 +3,12 @@ import { type EventBus } from '../events.js';
 import { type CanvasService } from './canvas.js';
 import { type CommentService } from './comments.js';
 import { type DocumentService } from './documents.js';
+import { type FolderService } from './folders.js';
 import { type NoteService } from './notes.js';
 import { type ProjectService } from './projects.js';
 import { type AgentRunService } from './agent-runs.js';
+import { type TagService } from './tags.js';
+import { type GoalService } from './goals.js';
 import { type TaskService } from './tasks.js';
 import { type TokenService } from './tokens.js';
 import { type ShareService } from './share.js';
@@ -17,9 +20,12 @@ export type ServicesDeps = {
 export type Services = {
     eventBus: EventBus;
     projectService: ProjectService;
+    goalService: GoalService;
     taskService: TaskService;
+    tagService: TagService;
     canvasService: CanvasService;
     documentService: DocumentService;
+    folderService: FolderService;
     noteService: NoteService;
     commentService: CommentService;
     agentRunService: AgentRunService;

package/dist/services/index.js

@@ -2,9 +2,12 @@ import { createEventBus } from '../events.js';
 import { createCanvasService } from './canvas.js';
 import { createCommentService } from './comments.js';
 import { createDocumentService } from './documents.js';
+import { createFolderService } from './folders.js';
 import { createNoteService } from './notes.js';
 import { createProjectService } from './projects.js';
 import { createAgentRunService } from './agent-runs.js';
+import { createTagService } from './tags.js';
+import { createGoalService } from './goals.js';
 import { createTaskService } from './tasks.js';
 import { createTokenService } from './tokens.js';
 import { createShareService } from './share.js';
@@ -12,9 +15,12 @@ import { createSyncService } from './sync.js';
 export function createServices(deps) {
     const eventBus = deps.eventBus ?? createEventBus();
     const projectService = createProjectService({ db: deps.db, eventBus });
+    const goalService = createGoalService({ db: deps.db, eventBus });
     const taskService = createTaskService({ db: deps.db, eventBus });
+    const tagService = createTagService({ db: deps.db, eventBus });
     const canvasService = createCanvasService({ db: deps.db, eventBus });
     const documentService = createDocumentService({ db: deps.db, eventBus });
+    const folderService = createFolderService({ db: deps.db, eventBus });
     const noteService = createNoteService({ db: deps.db, eventBus });
     const commentService = createCommentService({ db: deps.db, eventBus });
     const agentRunService = createAgentRunService({ db: deps.db, eventBus });
@@ -24,9 +30,12 @@ export function createServices(deps) {
     return {
         eventBus,
         projectService,
+        goalService,
         taskService,
+        tagService,
         canvasService,
         documentService,
+        folderService,
         noteService,
         commentService,
         agentRunService,

package/dist/services/projects.js

@@ -1,4 +1,4 @@
-import { clearDocumentParentRefsByProject, createDocument, createEdge, createProject as dbCreateProject, createTask, deleteAgentRun, deleteAgentRunEventsByRunId, deleteCommentsByProjectId, deleteDocumentsByProjectId, deleteNotesByProjectId, deleteEdgesByProjectId, deleteShareSubmissionsByProjectId, deleteSharesByProjectId, deleteSyncRemoteByProjectId, deleteSyncStateByProjectId, deleteProject as dbDeleteProject, deleteTasksByProjectId, getProject as dbGetProject, InvalidTaskStatusError, isTaskStatus, listAgentRuns, listProjects as dbListProjects, listTasks, updateProject as dbUpdateProject, } from '@plandesk/db';
+import { clearDocumentParentRefsByProject, clearFolderParentRefsByProject, createDocument, createEdge, createProject as dbCreateProject, createTask, deleteAgentRun, deleteAgentRunEventsByRunId, deleteCommentsByProjectId, deleteDocumentsByProjectId, deleteFoldersByProjectId, deleteNotesByProjectId, deleteEdgesByProjectId, deleteGoalsByProjectId, deleteShareSubmissionsByProjectId, deleteSharesByProjectId, deleteTagsByProjectId, deleteSyncRemoteByProjectId, deleteSyncStateByProjectId, deleteProject as dbDeleteProject, deleteTasksByProjectId, getOrCreateDefaultGoal, getProject as dbGetProject, InvalidTaskStatusError, isTaskStatus, listAgentRuns, listProjects as dbListProjects, listTasks, updateProject as dbUpdateProject, } from '@plandesk/db';
 import { emptyTaskStatusSummary, serializeDocument, serializeEdge, serializeProject, serializeProjectDetail, serializeTask, } from '../serialize.js';
 export class InvalidScaffoldError extends Error {
     constructor(message) {
@@ -89,8 +89,12 @@ export function createProjectService(deps) {
                 clearDocumentParentRefsByProject(tx, id);
                 deleteCommentsByProjectId(tx, id);
                 deleteDocumentsByProjectId(tx, id);
+                clearFolderParentRefsByProject(tx, id);
+                deleteFoldersByProjectId(tx, id);
                 deleteNotesByProjectId(tx, id);
+                deleteTagsByProjectId(tx, id);
                 deleteTasksByProjectId(tx, id);
+                deleteGoalsByProjectId(tx, id);
                 deleteShareSubmissionsByProjectId(tx, id);
                 deleteSyncStateByProjectId(tx, id);
                 deleteSyncRemoteByProjectId(tx, id);
@@ -113,11 +117,13 @@ export function createProjectService(deps) {
                     description: input.description,
                 });
                 projectId = project.id;
+                const defaultGoal = getOrCreateDefaultGoal(tx, project.id);
                 input.tasks.forEach((taskInput, i) => {
                     const x = taskInput.x ?? (i % 4) * 240;
                     const y = taskInput.y ?? Math.floor(i / 4) * 160;
                     const task = createTask(tx, {
                         projectId: project.id,
+                        goalId: defaultGoal.id,
                         label: taskInput.label,
                         status: taskInput.status,
                         description: taskInput.description,
@@ -164,7 +170,7 @@ export function createProjectService(deps) {
             }
             return {
                 project: serializeProject(project),
-                tasks: taskRows.map(serializeTask),
+                tasks: taskRows.map((task) => serializeTask(task)),
                 edges: edgeRows.map(serializeEdge),
                 documents: documentRows.map(serializeDocument),
                 key_to_id: Object.fromEntries(keyToId),