@ours.network/fleet 1.0.4 → 1.0.5

package/dist/rooms-tasks/task-lists.js

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { stateRoot } from '../paths.js';
+export const DEFAULT_TASK_LIST_ID = 'default';
+export const TASK_LIST_NAME_MAX_CODE_POINTS = 64;
+const CREATED_AT = '1970-01-01T00:00:00.000Z';
+export class TaskListError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'TaskListError';
+    }
+}
+export const taskListsPath = () => join(stateRoot(), 'task-lists.json');
+export const taskListsLockPath = () => join(stateRoot(), 'task-lists.lock');
+export const withTaskListsLock = (fn) => withFileLock(taskListsLockPath(), fn);
+const defaultList = () => ({
+    list_id: DEFAULT_TASK_LIST_ID, name: 'default', built_in: true, created_at: CREATED_AT,
+});
+const compareNames = (a, b) => {
+    if (a.list_id === DEFAULT_TASK_LIST_ID)
+        return b.list_id === DEFAULT_TASK_LIST_ID ? 0 : -1;
+    if (b.list_id === DEFAULT_TASK_LIST_ID)
+        return 1;
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : a.list_id.localeCompare(b.list_id);
+};
+export function normalizeTaskListName(input) {
+    if (typeof input !== 'string')
+        throw new TaskListError('invalid_name', 'list name must be a string');
+    const normalized = input.normalize('NFC');
+    if (normalized.trim() !== normalized || normalized.length === 0)
+        throw new TaskListError('invalid_name', 'list name must be non-empty with no leading or trailing whitespace');
+    if ([...normalized].length > TASK_LIST_NAME_MAX_CODE_POINTS)
+        throw new TaskListError('invalid_name', `list name must be at most ${TASK_LIST_NAME_MAX_CODE_POINTS} Unicode code points`);
+    if (/[\p{Cc}\p{Cf}\/\\]/u.test(normalized))
+        throw new TaskListError('invalid_name', 'list name contains a forbidden control, format, or path character');
+    return normalized;
+}
+export function readTaskLists() {
+    const path = taskListsPath();
+    if (!existsSync(path))
+        return [defaultList()];
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (parsed.version !== 1 || !Array.isArray(parsed.lists))
+        throw new Error('invalid task list registry');
+    const custom = parsed.lists.filter(item => item.list_id !== DEFAULT_TASK_LIST_ID);
+    return [defaultList(), ...custom].sort(compareNames);
+}
+function writeTaskLists(lists) {
+    const custom = lists.filter(item => item.list_id !== DEFAULT_TASK_LIST_ID).sort(compareNames);
+    replaceFileAtomically(taskListsPath(), JSON.stringify({ version: 1, lists: custom }, null, 2) + '\n');
+}
+export function resolveTaskList(name, lists = readTaskLists()) {
+    const normalized = normalizeTaskListName(name);
+    const found = lists.find(item => item.name === normalized);
+    if (!found)
+        throw new TaskListError('list_not_found', `task list not found: ${normalized}`);
+    return found;
+}
+/** Caller must hold withTaskListsLock. */
+export function createTaskListLocked(name) {
+    const normalized = normalizeTaskListName(name);
+    if (normalized === 'default')
+        throw new TaskListError('reserved_name', "'default' is a reserved built-in list");
+    const lists = readTaskLists();
+    if (lists.some(item => item.name === normalized))
+        throw new TaskListError('duplicate_name', `task list already exists: ${normalized}`);
+    const record = {
+        list_id: `list_${randomUUID().replace(/-/g, '')}`, name: normalized,
+        built_in: false, created_at: new Date().toISOString(),
+    };
+    writeTaskLists([...lists, record]);
+    return record;
+}
+/** Caller must hold withTaskListsLock. */
+export function renameTaskListLocked(currentName, nextName) {
+    const lists = readTaskLists();
+    const current = resolveTaskList(currentName, lists);
+    if (current.built_in)
+        throw new TaskListError('default_immutable', "the 'default' list cannot be renamed");
+    const normalized = normalizeTaskListName(nextName);
+    if (normalized === 'default')
+        throw new TaskListError('reserved_name', "'default' is a reserved built-in list");
+    if (lists.some(item => item.list_id !== current.list_id && item.name === normalized))
+        throw new TaskListError('duplicate_name', `task list already exists: ${normalized}`);
+    const renamed = { ...current, name: normalized };
+    writeTaskLists(lists.map(item => item.list_id === current.list_id ? renamed : item));
+    return renamed;
+}
+/** Caller must hold withTaskListsLock. */
+export function deleteTaskListRecordLocked(listId) {
+    writeTaskLists(readTaskLists().filter(item => item.list_id !== listId));
+}

package/dist/rooms-tasks/task-state.d.ts

@@ -12,12 +12,15 @@ export interface CreateTaskInput {
     start?: boolean;
     no_room?: boolean;
     room_id?: string;
+    listId?: string;
 }
 export declare function createTask(input: CreateTaskInput): TaskRecord;
 export declare function getTask(id: string): TaskRecord;
 export declare function listTasks(filter?: {
     state?: TaskState | TaskState[];
+    listId?: string;
 }): TaskRecord[];
+export declare function moveTaskToList(id: string, listId: string): TaskRecord;
 export declare function findByIdempotencyKey(key: string): TaskRecord | undefined;
 export declare function startTask(id: string): TaskRecord;
 export declare function activateTask(id: string): TaskRecord;

package/dist/rooms-tasks/task-state.js

@@ -1,11 +1,66 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, rmSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
 import { TASK_TERMINAL_STATES, TASK_CANCELLABLE_STATES } from './types.js';
+import { DEFAULT_TASK_LIST_ID, readTaskLists } from './task-lists.js';
 export const tasksDir = () => join(stateRoot(), 'tasks');
 function taskPath(id) { return join(tasksDir(), `${id}.json`); }
+function taskLockPath(id) { return join(tasksDir(), '.locks', id); }
+const localTaskLocks = new Set();
+function withTaskLock(id, fn) {
+    if (localTaskLocks.has(id))
+        return fn();
+    const path = taskLockPath(id);
+    const ownerPath = join(path, 'owner.json');
+    const token = randomUUID();
+    mkdirSync(join(tasksDir(), '.locks'), { recursive: true });
+    for (;;) {
+        const claimPath = `${path}.claim.${process.pid}.${randomUUID()}`;
+        try {
+            mkdirSync(claimPath);
+            writeFileSync(join(claimPath, 'owner.json'), JSON.stringify({ token, pid: process.pid }));
+            renameSync(claimPath, path);
+            break;
+        }
+        catch (error) {
+            rmSync(claimPath, { recursive: true, force: true });
+            if (!['EEXIST', 'ENOTEMPTY'].includes(error.code ?? ''))
+                throw error;
+            let alive = false;
+            try {
+                const owner = JSON.parse(readFileSync(ownerPath, 'utf8'));
+                if (typeof owner.pid === 'number') {
+                    try {
+                        process.kill(owner.pid, 0);
+                        alive = true;
+                    }
+                    catch { /* dead */ }
+                }
+            }
+            catch { /* corrupt legacy lock */ }
+            if (!alive) {
+                rmSync(path, { recursive: true, force: true });
+                continue;
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    }
+    localTaskLocks.add(id);
+    try {
+        return fn();
+    }
+    finally {
+        localTaskLocks.delete(id);
+        try {
+            const owner = JSON.parse(readFileSync(ownerPath, 'utf8'));
+            if (owner.token === token)
+                rmSync(path, { recursive: true, force: true });
+        }
+        catch { /* ownership cannot be proved */ }
+    }
+}
 function generateTaskId() {
     const ts = Date.now().toString(36).padStart(9, '0');
     const rand = randomUUID().replace(/-/g, '').slice(0, 8);
@@ -27,11 +82,20 @@ function readTask(id) {
     const p = taskPath(id);
     if (!existsSync(p))
         throw new TaskStateError(`task not found: ${id}`);
-    return JSON.parse(readFileSync(p, 'utf8'));
+    return presentTask(JSON.parse(readFileSync(p, 'utf8')));
 }
 function writeTask(record) {
     mkdirSync(tasksDir(), { recursive: true });
-    replaceFileAtomically(taskPath(record.task_id), JSON.stringify(record, null, 2) + '\n');
+    const persisted = { ...record };
+    delete persisted.list_name;
+    replaceFileAtomically(taskPath(record.task_id), JSON.stringify(persisted, null, 2) + '\n');
+}
+function presentTask(record) {
+    const listId = record.list_id ?? DEFAULT_TASK_LIST_ID;
+    const list = readTaskLists().find(item => item.list_id === listId);
+    if (!list)
+        throw new TaskStateError(`task ${record.task_id} references missing list ${listId}`);
+    return { ...record, list_id: listId, list_name: list.name };
 }
 // ── Lifecycle transitions ───────────────────────────────────────────────
 const VALID_TRANSITIONS = {
@@ -60,6 +124,7 @@ export function createTask(input) {
     const state = input.start === false ? 'backlog' : 'provisioning';
     const record = {
         task_id: generateTaskId(),
+        list_id: input.listId ?? DEFAULT_TASK_LIST_ID,
         title: input.title,
         brief: input.brief,
         brief_file: input.brief_file,
@@ -74,9 +139,9 @@ export function createTask(input) {
         started_at: state === 'provisioning' ? new Date().toISOString() : undefined,
     };
     writeTask(record);
-    return record;
+    return readTask(record.task_id);
 }
-export function getTask(id) { return readTask(id); }
+export function getTask(id) { return withTaskLock(id, () => readTask(id)); }
 export function listTasks(filter) {
     const dir = tasksDir();
     if (!existsSync(dir))
@@ -87,222 +152,263 @@ export function listTasks(filter) {
     const tasks = [];
     for (const f of readdirSync(dir).filter(f => f.endsWith('.json'))) {
         try {
-            const t = JSON.parse(readFileSync(join(dir, f), 'utf8'));
-            if (!states || states.includes(t.state))
+            const id = f.slice(0, -5);
+            const t = withTaskLock(id, () => presentTask(JSON.parse(readFileSync(join(dir, f), 'utf8'))));
+            if ((!states || states.includes(t.state)) && (!filter?.listId || t.list_id === filter.listId))
                 tasks.push(t);
         }
         catch { /* corrupt file, skip */ }
     }
-    return tasks.sort((a, b) => a.created_at.localeCompare(b.created_at));
+    const order = new Map(readTaskLists().map((item, index) => [item.list_id, index]));
+    return tasks.sort((a, b) => (order.get(a.list_id) - order.get(b.list_id))
+        || a.created_at.localeCompare(b.created_at) || a.task_id.localeCompare(b.task_id));
+}
+export function moveTaskToList(id, listId) {
+    return withTaskLock(id, () => {
+        const task = readTask(id);
+        task.list_id = listId;
+        writeTask(task);
+        return readTask(id);
+    });
 }
 export function findByIdempotencyKey(key) {
     return listTasks().find(t => t.idempotency_key === key);
 }
 export function startTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'provisioning');
-    t.state = 'provisioning';
-    t.started_at = new Date().toISOString();
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'provisioning');
+        t.state = 'provisioning';
+        t.started_at = new Date().toISOString();
+        writeTask(t);
+        return t;
+    });
 }
 export function activateTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'active');
-    t.state = 'active';
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'active');
+        t.state = 'active';
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 export function blockTask(id, reason) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    if (TASK_TERMINAL_STATES.includes(t.state))
-        throw new TaskStateError(`cannot block a '${t.state}' task`);
-    t.blocked = { reason, at: new Date().toISOString() };
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        if (TASK_TERMINAL_STATES.includes(t.state))
+            throw new TaskStateError(`cannot block a '${t.state}' task`);
+        t.blocked = { reason, at: new Date().toISOString() };
+        writeTask(t);
+        return t;
+    });
 }
 export function unblockTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    if (!t.blocked)
-        throw new TaskStateError('task is not blocked');
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        if (!t.blocked)
+            throw new TaskStateError('task is not blocked');
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 export function reviewTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'review');
-    t.state = 'review';
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'review');
+        t.state = 'review';
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 export function completeTask(id, outcome) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'done');
-    t.state = 'done';
-    t.ended_at = new Date().toISOString();
-    delete t.blocked;
-    if (outcome)
-        t.outcome = outcome;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'done');
+        t.state = 'done';
+        t.ended_at = new Date().toISOString();
+        delete t.blocked;
+        if (outcome)
+            t.outcome = outcome;
+        writeTask(t);
+        return t;
+    });
 }
 export function cancelTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    if (!TASK_CANCELLABLE_STATES.includes(t.state))
-        throw new TaskStateError(`cannot cancel a '${t.state}' task`);
-    t.state = 'cancelled';
-    t.ended_at = new Date().toISOString();
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        if (!TASK_CANCELLABLE_STATES.includes(t.state))
+            throw new TaskStateError(`cannot cancel a '${t.state}' task`);
+        t.state = 'cancelled';
+        t.ended_at = new Date().toISOString();
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 function sameOutcome(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
 }
 /** Persist the first terminal request. Callers serialize this with the task-operation lock. */
 export function beginTaskTerminalIntent(id, input) {
-    const t = readTask(id);
-    const existing = t.terminal_intent;
-    if (existing) {
-        if (existing.kind !== input.kind || existing.room_id !== input.roomId
-            || !sameOutcome(existing.outcome, input.outcome)) {
-            throw new TaskStateError(`task ${id} already has a conflicting '${existing.kind}' terminal intent`);
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        const existing = t.terminal_intent;
+        if (existing) {
+            if (existing.kind !== input.kind || existing.room_id !== input.roomId
+                || !sameOutcome(existing.outcome, input.outcome)) {
+                throw new TaskStateError(`task ${id} already has a conflicting '${existing.kind}' terminal intent`);
+            }
+            return t;
+        }
+        if (TASK_TERMINAL_STATES.includes(t.state)) {
+            throw new TaskStateError(`task ${id} is already in terminal state '${t.state}'`);
         }
+        if (input.kind === 'done' && t.state !== 'review') {
+            throw new TaskStateError(`cannot transition from '${t.state}' to 'done'`);
+        }
+        if (input.kind === 'cancelled' && !TASK_CANCELLABLE_STATES.includes(t.state)) {
+            throw new TaskStateError(`cannot cancel a '${t.state}' task`);
+        }
+        if (input.roomId !== undefined && t.room_id !== input.roomId) {
+            throw new TaskStateError(`task ${id} is not tied to room ${input.roomId}`);
+        }
+        t.terminal_intent = {
+            kind: input.kind,
+            status: 'pending',
+            room_id: input.roomId,
+            outcome: input.outcome,
+            accepted_at: new Date().toISOString(),
+        };
+        writeTask(t);
         return t;
-    }
-    if (TASK_TERMINAL_STATES.includes(t.state)) {
-        throw new TaskStateError(`task ${id} is already in terminal state '${t.state}'`);
-    }
-    if (input.kind === 'done' && t.state !== 'review') {
-        throw new TaskStateError(`cannot transition from '${t.state}' to 'done'`);
-    }
-    if (input.kind === 'cancelled' && !TASK_CANCELLABLE_STATES.includes(t.state)) {
-        throw new TaskStateError(`cannot cancel a '${t.state}' task`);
-    }
-    if (input.roomId !== undefined && t.room_id !== input.roomId) {
-        throw new TaskStateError(`task ${id} is not tied to room ${input.roomId}`);
-    }
-    t.terminal_intent = {
-        kind: input.kind,
-        status: 'pending',
-        room_id: input.roomId,
-        outcome: input.outcome,
-        accepted_at: new Date().toISOString(),
-    };
-    writeTask(t);
-    return t;
+    });
 }
 /** Record an actionable failure without claiming the requested terminal state. */
 export function setTaskTerminalIntentError(id, error, recoveryHint) {
-    const t = readTask(id);
-    if (!t.terminal_intent)
-        throw new TaskStateError(`task ${id} has no terminal intent`);
-    if (t.terminal_intent.status === 'settled')
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        if (!t.terminal_intent)
+            throw new TaskStateError(`task ${id} has no terminal intent`);
+        if (t.terminal_intent.status === 'settled')
+            return t;
+        t.terminal_intent.first_failure ??= error;
+        t.terminal_intent.first_recovery_hint ??= recoveryHint;
+        t.terminal_intent.error = error;
+        const previousErrorAt = Date.parse(t.terminal_intent.error_at ?? '');
+        t.terminal_intent.error_at = new Date(Math.max(Date.now(), Number.isFinite(previousErrorAt) ? previousErrorAt + 1 : 0)).toISOString();
+        t.terminal_intent.recovery_hint = recoveryHint;
+        writeTask(t);
         return t;
-    t.terminal_intent.first_failure ??= error;
-    t.terminal_intent.first_recovery_hint ??= recoveryHint;
-    t.terminal_intent.error = error;
-    const previousErrorAt = Date.parse(t.terminal_intent.error_at ?? '');
-    t.terminal_intent.error_at = new Date(Math.max(Date.now(), Number.isFinite(previousErrorAt) ? previousErrorAt + 1 : 0)).toISOString();
-    t.terminal_intent.recovery_hint = recoveryHint;
-    writeTask(t);
-    return t;
+    });
 }
 /** Atomically publish the task terminal state and settled audit cursor. */
 export function finishTaskTerminalIntent(id) {
-    const t = readTask(id);
-    const intent = t.terminal_intent;
-    if (!intent)
-        throw new TaskStateError(`task ${id} has no terminal intent`);
-    if (intent.status === 'settled')
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        const intent = t.terminal_intent;
+        if (!intent)
+            throw new TaskStateError(`task ${id} has no terminal intent`);
+        if (intent.status === 'settled')
+            return t;
+        if (TASK_TERMINAL_STATES.includes(t.state)) {
+            throw new TaskStateError(`task ${id} reached terminal state '${t.state}' outside its intent`);
+        }
+        if (intent.kind === 'done')
+            assertTransition(t.state, 'done');
+        else if (!TASK_CANCELLABLE_STATES.includes(t.state)) {
+            throw new TaskStateError(`cannot cancel a '${t.state}' task`);
+        }
+        t.state = intent.kind;
+        t.ended_at = new Date().toISOString();
+        delete t.blocked;
+        if (intent.outcome)
+            t.outcome = intent.outcome;
+        intent.status = 'settled';
+        intent.settled_at = t.ended_at;
+        delete intent.error;
+        delete intent.error_at;
+        delete intent.recovery_hint;
+        writeTask(t);
         return t;
-    if (TASK_TERMINAL_STATES.includes(t.state)) {
-        throw new TaskStateError(`task ${id} reached terminal state '${t.state}' outside its intent`);
-    }
-    if (intent.kind === 'done')
-        assertTransition(t.state, 'done');
-    else if (!TASK_CANCELLABLE_STATES.includes(t.state)) {
-        throw new TaskStateError(`cannot cancel a '${t.state}' task`);
-    }
-    t.state = intent.kind;
-    t.ended_at = new Date().toISOString();
-    delete t.blocked;
-    if (intent.outcome)
-        t.outcome = intent.outcome;
-    intent.status = 'settled';
-    intent.settled_at = t.ended_at;
-    delete intent.error;
-    delete intent.error_at;
-    delete intent.recovery_hint;
-    writeTask(t);
-    return t;
+    });
 }
 export function failTask(id, error) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'failed');
-    t.state = 'failed';
-    t.ended_at = new Date().toISOString();
-    t.outcome = { summary: error };
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'failed');
+        t.state = 'failed';
+        t.ended_at = new Date().toISOString();
+        t.outcome = { summary: error };
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 export function updateTaskRoom(id, roomId, roomIdentityCid) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    t.room_id = roomId;
-    t.room_identity_cid = roomIdentityCid;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        t.room_id = roomId;
+        t.room_identity_cid = roomIdentityCid;
+        writeTask(t);
+        return t;
+    });
 }
 export function updateTaskTemplate(id, template) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    t.template = template;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        t.template = template;
+        writeTask(t);
+        return t;
+    });
 }
 export function updateTaskMembers(id, members) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    t.member_roles = members;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        t.member_roles = members;
+        writeTask(t);
+        return t;
+    });
 }
 /** Remove a completed task from Fleet's backlog. Missing tasks are an idempotent no-op. */
 export function deleteTask(id) {
-    assertCanonicalTaskId(id);
-    const p = taskPath(id);
-    let task;
-    try {
-        task = JSON.parse(readFileSync(p, 'utf8'));
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return false;
-        throw error;
-    }
-    if (task.state !== 'done') {
-        throw new TaskStateError(`cannot delete a '${task.state}' task; only 'done' tasks can be deleted`);
-    }
-    try {
-        unlinkSync(p);
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return false;
-        throw error;
-    }
-    return true;
+    return withTaskLock(id, () => {
+        assertCanonicalTaskId(id);
+        const p = taskPath(id);
+        let task;
+        try {
+            task = JSON.parse(readFileSync(p, 'utf8'));
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return false;
+            throw error;
+        }
+        if (task.state !== 'done') {
+            throw new TaskStateError(`cannot delete a '${task.state}' task; only 'done' tasks can be deleted`);
+        }
+        try {
+            unlinkSync(p);
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return false;
+            throw error;
+        }
+        return true;
+    });
 }