discoclaw 0.1.0

package/dist/tasks/migrate.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs/promises';
+import { bdList } from './bd-cli.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Write an array of TaskData records to a JSONL file (one JSON object per line).
+ * Exported separately so tests can exercise the write path without a live bd install.
+ */
+export async function writeJsonl(destPath, tasks) {
+    const lines = tasks.map((b) => JSON.stringify(b)).join('\n');
+    await fs.writeFile(destPath, lines ? lines + '\n' : '', 'utf8');
+}
+// ---------------------------------------------------------------------------
+// Migration entry point
+// ---------------------------------------------------------------------------
+/**
+ * One-shot migration: reads **all** tasks from the bd CLI (all statuses, no
+ * limit) and writes them as JSONL to `destPath` so that `TaskStore.load()`
+ * can consume them.
+ *
+ * The output file is a full replacement — any existing content is overwritten.
+ * After migration, create a `TaskStore` with `persistPath: destPath` and call
+ * `await store.load()` to make the data available in-process.
+ */
+export async function migrateFromBd(opts) {
+    const tasks = await bdList({ status: 'all', limit: 0 }, opts.cwd);
+    if (tasks.length === 0) {
+        console.warn('[migrate] bd exported zero tasks — if you expected data, check that bd is pointed at the right workspace. Writing empty JSONL.');
+    }
+    await writeJsonl(opts.destPath, tasks);
+    return { migrated: tasks.length };
+}

package/dist/tasks/migrate.test.js

@@ -0,0 +1,156 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { migrateFromBd, writeJsonl } from './migrate.js';
+import { TaskStore } from './store.js';
+vi.mock('./bd-cli.js', () => ({
+    bdList: vi.fn(),
+}));
+import { bdList } from './bd-cli.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const TMP_PATH = (suffix) => `/tmp/discoclaw-migrate-test-${suffix}.jsonl`;
+async function cleanup(path) {
+    const { unlink } = await import('node:fs/promises');
+    await unlink(path).catch(() => { });
+}
+// ---------------------------------------------------------------------------
+// writeJsonl
+// ---------------------------------------------------------------------------
+describe('migrate — writeJsonl', () => {
+    it('writes beads as JSONL and allows TaskStore to load them', async () => {
+        const path = TMP_PATH('write-load');
+        await cleanup(path);
+        const tasks = [
+            { id: 'ws-001', title: 'Alpha', status: 'open', created_at: '2024-01-01T00:00:00Z', updated_at: '2024-01-01T00:00:00Z' },
+            { id: 'ws-002', title: 'Beta', status: 'closed', closed_at: '2024-01-02T00:00:00Z', updated_at: '2024-01-02T00:00:00Z' },
+        ];
+        await writeJsonl(path, tasks);
+        const store = new TaskStore({ prefix: 'ws', persistPath: path });
+        await store.load();
+        expect(store.size()).toBe(2);
+        expect(store.list({ status: 'all' }).map((b) => b.id).sort()).toEqual(['ws-001', 'ws-002']);
+        await cleanup(path);
+    });
+    it('preserves all TaskData fields in the JSONL output', async () => {
+        const path = TMP_PATH('fields');
+        await cleanup(path);
+        const bead = {
+            id: 'ws-005',
+            title: 'Rich task',
+            status: 'in_progress',
+            description: 'some desc',
+            priority: 1,
+            issue_type: 'bug',
+            owner: 'alice',
+            external_ref: 'discord:123',
+            labels: ['plan', 'tag:feature'],
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-02T00:00:00Z',
+        };
+        await writeJsonl(path, [bead]);
+        const store = new TaskStore({ prefix: 'ws', persistPath: path });
+        await store.load();
+        const loaded = store.get('ws-005');
+        expect(loaded.description).toBe('some desc');
+        expect(loaded.priority).toBe(1);
+        expect(loaded.issue_type).toBe('bug');
+        expect(loaded.owner).toBe('alice');
+        expect(loaded.external_ref).toBe('discord:123');
+        expect(loaded.labels).toEqual(['plan', 'tag:feature']);
+        await cleanup(path);
+    });
+    it('writes an empty file for an empty bead array', async () => {
+        const path = TMP_PATH('empty');
+        await cleanup(path);
+        await writeJsonl(path, []);
+        const { readFile } = await import('node:fs/promises');
+        const content = await readFile(path, 'utf8');
+        expect(content).toBe('');
+        await cleanup(path);
+    });
+    it('counter advances past the highest migrated ID so new tasks get non-colliding IDs', async () => {
+        const path = TMP_PATH('counter');
+        await cleanup(path);
+        const tasks = [
+            { id: 'ws-003', title: 'C', status: 'open' },
+            { id: 'ws-001', title: 'A', status: 'open' },
+            { id: 'ws-007', title: 'G', status: 'open' },
+        ];
+        await writeJsonl(path, tasks);
+        const store = new TaskStore({ prefix: 'ws', persistPath: path });
+        await store.load();
+        const next = store.create({ title: 'New' });
+        expect(next.id).toBe('ws-008');
+        await cleanup(path);
+    });
+});
+// ---------------------------------------------------------------------------
+// migrateFromBd
+// ---------------------------------------------------------------------------
+describe('migrate — migrateFromBd', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('calls bdList with status:all and limit:0 and writes all beads to destPath', async () => {
+        const path = TMP_PATH('bd-basic');
+        await cleanup(path);
+        const mockBeads = [
+            { id: 'dc-001', title: 'Task one', status: 'open', created_at: '2024-01-01T00:00:00Z', updated_at: '2024-01-01T00:00:00Z' },
+            { id: 'dc-002', title: 'Task two', status: 'in_progress', created_at: '2024-01-01T00:00:00Z', updated_at: '2024-01-01T00:00:00Z' },
+        ];
+        vi.mocked(bdList).mockResolvedValueOnce(mockBeads);
+        const result = await migrateFromBd({ cwd: '/tmp/fake-workspace', destPath: path });
+        expect(result.migrated).toBe(2);
+        expect(bdList).toHaveBeenCalledOnce();
+        expect(bdList).toHaveBeenCalledWith({ status: 'all', limit: 0 }, '/tmp/fake-workspace');
+        const store = new TaskStore({ prefix: 'dc', persistPath: path });
+        await store.load();
+        expect(store.size()).toBe(2);
+        expect(store.list({ status: 'all' }).map((b) => b.title).sort()).toEqual(['Task one', 'Task two']);
+        await cleanup(path);
+    });
+    it('returns migrated: 0, writes an empty file, and warns when bd has no beads', async () => {
+        const path = TMP_PATH('bd-empty');
+        await cleanup(path);
+        vi.mocked(bdList).mockResolvedValueOnce([]);
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        try {
+            const result = await migrateFromBd({ cwd: '/tmp/fake-workspace', destPath: path });
+            expect(result.migrated).toBe(0);
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('zero tasks'));
+            const { readFile } = await import('node:fs/promises');
+            const content = await readFile(path, 'utf8');
+            expect(content).toBe('');
+        }
+        finally {
+            warnSpy.mockRestore();
+            await cleanup(path);
+        }
+    });
+    it('overwrites an existing JSONL file', async () => {
+        const path = TMP_PATH('bd-overwrite');
+        await cleanup(path);
+        // First write
+        vi.mocked(bdList).mockResolvedValueOnce([
+            { id: 'ws-001', title: 'Old', status: 'open' },
+        ]);
+        await migrateFromBd({ cwd: '/tmp/fake-workspace', destPath: path });
+        // Second write with different data
+        vi.mocked(bdList).mockResolvedValueOnce([
+            { id: 'ws-010', title: 'New', status: 'open' },
+        ]);
+        const result = await migrateFromBd({ cwd: '/tmp/fake-workspace', destPath: path });
+        expect(result.migrated).toBe(1);
+        const store = new TaskStore({ prefix: 'ws', persistPath: path });
+        await store.load();
+        expect(store.size()).toBe(1);
+        expect(store.get('ws-010')?.title).toBe('New');
+        expect(store.get('ws-001')).toBeUndefined();
+        await cleanup(path);
+    });
+    it('propagates bdList errors to the caller', async () => {
+        const path = TMP_PATH('bd-error');
+        vi.mocked(bdList).mockRejectedValueOnce(new Error('bd: database not found'));
+        await expect(migrateFromBd({ cwd: '/tmp/fake-workspace', destPath: path })).rejects.toThrow('bd: database not found');
+    });
+});

package/dist/tasks/path-defaults.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Resolve canonical task data paths.
+ *
+ * Returns `<dataDir>/tasks/<fileName>`.
+ */
+export function resolveTaskDataPath(dataDir, fileName) {
+    if (!dataDir)
+        return undefined;
+    return path.join(dataDir, 'tasks', fileName);
+}
+/**
+ * Resolve legacy task data paths retained from the pre-hard-cut layout.
+ *
+ * Returns `<dataDir>/beads/<fileName>`.
+ */
+export function resolveLegacyTaskDataPath(dataDir, fileName) {
+    if (!dataDir)
+        return undefined;
+    return path.join(dataDir, 'beads', fileName);
+}
+async function fileExists(filePath) {
+    if (!filePath)
+        return false;
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the best task data file path for read/load operations:
+ * - canonical path when present
+ * - legacy path when canonical is missing but legacy exists
+ * - canonical path as the write target when neither exists yet
+ */
+export async function resolveTaskDataLoadPath(dataDir, fileName) {
+    const canonicalPath = resolveTaskDataPath(dataDir, fileName);
+    if (!canonicalPath)
+        return undefined;
+    if (await fileExists(canonicalPath))
+        return canonicalPath;
+    const legacyPath = resolveLegacyTaskDataPath(dataDir, fileName);
+    if (await fileExists(legacyPath))
+        return legacyPath;
+    return canonicalPath;
+}
+/**
+ * Copy a legacy task data file from `<dataDir>/beads/` to the canonical
+ * `<dataDir>/tasks/` path when the canonical file is missing.
+ */
+export async function migrateLegacyTaskDataFile(dataDir, fileName) {
+    const toPath = resolveTaskDataPath(dataDir, fileName);
+    const fromPath = resolveLegacyTaskDataPath(dataDir, fileName);
+    if (!toPath || !fromPath)
+        return { migrated: false };
+    if (await fileExists(toPath))
+        return { migrated: false };
+    if (!(await fileExists(fromPath)))
+        return { migrated: false };
+    await fs.mkdir(path.dirname(toPath), { recursive: true });
+    await fs.copyFile(fromPath, toPath);
+    return { migrated: true, fromPath, toPath };
+}

package/dist/tasks/path-defaults.test.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import os from 'node:os';
+import { migrateLegacyTaskDataFile, resolveLegacyTaskDataPath, resolveTaskDataLoadPath, resolveTaskDataPath, } from './path-defaults.js';
+describe('resolveTaskDataPath', () => {
+    it('returns undefined when dataDir is not provided', () => {
+        expect(resolveTaskDataPath(undefined, 'tasks.jsonl')).toBeUndefined();
+    });
+    it('returns canonical path for tasks.jsonl', () => {
+        const dataDir = '/tmp/discoclaw-data';
+        const result = resolveTaskDataPath(dataDir, 'tasks.jsonl');
+        expect(result).toBe(path.join(dataDir, 'tasks', 'tasks.jsonl'));
+    });
+    it('returns canonical path for tag-map.json', () => {
+        const dataDir = '/tmp/discoclaw-data';
+        const canonical = path.join(dataDir, 'tasks', 'tag-map.json');
+        const result = resolveTaskDataPath(dataDir, 'tag-map.json');
+        expect(result).toBe(canonical);
+    });
+});
+describe('resolveLegacyTaskDataPath', () => {
+    it('returns undefined when dataDir is not provided', () => {
+        expect(resolveLegacyTaskDataPath(undefined, 'tasks.jsonl')).toBeUndefined();
+    });
+    it('returns legacy path for tasks.jsonl', () => {
+        const dataDir = '/tmp/discoclaw-data';
+        const result = resolveLegacyTaskDataPath(dataDir, 'tasks.jsonl');
+        expect(result).toBe(path.join(dataDir, 'beads', 'tasks.jsonl'));
+    });
+});
+describe('resolveTaskDataLoadPath', () => {
+    it('prefers legacy path when canonical is missing', async () => {
+        const dataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'discoclaw-path-'));
+        const legacyPath = path.join(dataDir, 'beads', 'tasks.jsonl');
+        await fs.mkdir(path.dirname(legacyPath), { recursive: true });
+        await fs.writeFile(legacyPath, '{"id":"dev-001"}\n', 'utf8');
+        const resolved = await resolveTaskDataLoadPath(dataDir, 'tasks.jsonl');
+        expect(resolved).toBe(legacyPath);
+    });
+    it('returns canonical path when neither file exists yet', async () => {
+        const dataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'discoclaw-path-'));
+        const resolved = await resolveTaskDataLoadPath(dataDir, 'tasks.jsonl');
+        expect(resolved).toBe(path.join(dataDir, 'tasks', 'tasks.jsonl'));
+    });
+});
+describe('migrateLegacyTaskDataFile', () => {
+    it('copies legacy tasks file to canonical location when missing', async () => {
+        const dataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'discoclaw-migrate-'));
+        const fromPath = path.join(dataDir, 'beads', 'tasks.jsonl');
+        const toPath = path.join(dataDir, 'tasks', 'tasks.jsonl');
+        const payload = '{"id":"dev-5ayj","status":"closed"}\n';
+        await fs.mkdir(path.dirname(fromPath), { recursive: true });
+        await fs.writeFile(fromPath, payload, 'utf8');
+        const result = await migrateLegacyTaskDataFile(dataDir, 'tasks.jsonl');
+        const copied = await fs.readFile(toPath, 'utf8');
+        expect(result).toEqual({ migrated: true, fromPath, toPath });
+        expect(copied).toBe(payload);
+    });
+    it('does nothing when canonical file already exists', async () => {
+        const dataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'discoclaw-migrate-'));
+        const toPath = path.join(dataDir, 'tasks', 'tasks.jsonl');
+        const fromPath = path.join(dataDir, 'beads', 'tasks.jsonl');
+        await fs.mkdir(path.dirname(toPath), { recursive: true });
+        await fs.mkdir(path.dirname(fromPath), { recursive: true });
+        await fs.writeFile(toPath, '{"id":"ws-001"}\n', 'utf8');
+        await fs.writeFile(fromPath, '{"id":"dev-001"}\n', 'utf8');
+        const result = await migrateLegacyTaskDataFile(dataDir, 'tasks.jsonl');
+        const existing = await fs.readFile(toPath, 'utf8');
+        expect(result).toEqual({ migrated: false });
+        expect(existing).toBe('{"id":"ws-001"}\n');
+    });
+});

package/dist/tasks/runtime-types.js

@@ -0,0 +1 @@
+export {};

package/dist/tasks/service.js

@@ -0,0 +1,33 @@
+/**
+ * Track 2 mutation entrypoint.
+ * This wraps TaskStore so callers can depend on one service contract while
+ * we progressively move domain rules out of adapters.
+ */
+export function createTaskService(store) {
+    return {
+        get(id) {
+            return store.get(id);
+        },
+        list(params) {
+            return store.list(params);
+        },
+        findByTitle(title, opts) {
+            return store.findByTitle(title, opts);
+        },
+        create(params) {
+            return store.create(params);
+        },
+        update(id, params) {
+            return store.update(id, params);
+        },
+        close(id, reason) {
+            return store.close(id, reason);
+        },
+        addLabel(id, label) {
+            return store.addLabel(id, label);
+        },
+        removeLabel(id, label) {
+            return store.removeLabel(id, label);
+        },
+    };
+}

package/dist/tasks/service.test.js

@@ -0,0 +1,51 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createTaskService } from './service.js';
+import { TaskStore } from './store.js';
+describe('createTaskService', () => {
+    it('delegates reads and writes to TaskStore', () => {
+        const store = new TaskStore({ prefix: 'ws' });
+        const service = createTaskService(store);
+        const created = service.create({ title: 'Service task', labels: ['plan'] });
+        expect(service.get(created.id)?.title).toBe('Service task');
+        expect(service.list({ status: 'all' }).map((t) => t.id)).toContain(created.id);
+        expect(service.findByTitle('service task')?.id).toBe(created.id);
+        service.update(created.id, { status: 'in_progress' });
+        expect(service.get(created.id)?.status).toBe('in_progress');
+        service.addLabel(created.id, 'tag:feature');
+        expect(service.get(created.id)?.labels).toContain('tag:feature');
+        service.removeLabel(created.id, 'tag:feature');
+        expect(service.get(created.id)?.labels).not.toContain('tag:feature');
+        service.close(created.id, 'done');
+        expect(service.get(created.id)?.status).toBe('closed');
+    });
+    it('preserves TaskStore event semantics through service writes', () => {
+        const store = new TaskStore({ prefix: 'ws' });
+        const service = createTaskService(store);
+        const events = [];
+        store.on('created', () => events.push('created'));
+        store.on('updated', () => events.push('updated'));
+        store.on('labeled', () => events.push('labeled'));
+        store.on('closed', () => events.push('closed'));
+        const task = service.create({ title: 'Event task' });
+        service.update(task.id, { title: 'Event task v2' });
+        service.addLabel(task.id, 'plan');
+        service.removeLabel(task.id, 'plan');
+        service.close(task.id);
+        expect(events).toEqual(['created', 'updated', 'labeled', 'updated', 'closed']);
+    });
+    it('can be passed a mocked store contract for isolated callers', () => {
+        const store = {
+            get: vi.fn(),
+            list: vi.fn(() => []),
+            findByTitle: vi.fn(() => null),
+            create: vi.fn((params) => ({ id: 'ws-001', ...params, status: 'open' })),
+            update: vi.fn(),
+            close: vi.fn(),
+            addLabel: vi.fn(),
+            removeLabel: vi.fn(),
+        };
+        const service = createTaskService(store);
+        service.create({ title: 'mocked' });
+        expect(store.create).toHaveBeenCalledWith({ title: 'mocked' });
+    });
+});

package/dist/tasks/store.js

@@ -0,0 +1,238 @@
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs/promises';
+// ---------------------------------------------------------------------------
+// TaskStore
+// ---------------------------------------------------------------------------
+/**
+ * In-process task store — an EventEmitter-backed Map that owns the read/write
+ * path for task data. Replaces the external `bd` CLI dependency.
+ *
+ * All mutations are synchronous on the in-memory store and emit typed events
+ * immediately. Persistence to a JSONL file (if configured) is fire-and-forget;
+ * call `flush()` to await the latest write.
+ */
+export class TaskStore extends EventEmitter {
+    tasks = new Map();
+    counter = 0;
+    prefix;
+    persistPath;
+    persistPromise = null;
+    constructor(opts = {}) {
+        super();
+        this.prefix = opts.prefix ?? 't';
+        this.persistPath = opts.persistPath;
+    }
+    // ---------------------------------------------------------------------------
+    // Persistence
+    // ---------------------------------------------------------------------------
+    /**
+     * Load tasks from the configured JSONL file. No-op if no persistPath was
+     * given. Silently succeeds if the file does not exist yet.
+     */
+    async load() {
+        if (!this.persistPath)
+            return;
+        let content;
+        try {
+            content = await fs.readFile(this.persistPath, 'utf8');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return;
+            throw err;
+        }
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const task = JSON.parse(trimmed);
+            this.tasks.set(task.id, task);
+            // Advance the counter to be ≥ the highest numeric suffix seen,
+            // but only for IDs that share our prefix to avoid contamination
+            // from migrated tasks with different prefixes (e.g. dev-899 → ws-900).
+            const match = new RegExp(`^${this.prefix}-(\\d+)$`).exec(task.id);
+            if (match) {
+                const n = parseInt(match[1], 10);
+                if (n > this.counter)
+                    this.counter = n;
+            }
+        }
+    }
+    /** Await the most recently scheduled persist, if any. */
+    async flush() {
+        await this.persistPromise;
+    }
+    schedulePersist() {
+        if (!this.persistPath)
+            return;
+        this.persistPromise = (this.persistPromise ?? Promise.resolve())
+            .then(() => this.writeToDisk())
+            .catch(() => {
+            // Persist errors are non-fatal; in-memory state remains authoritative.
+        });
+    }
+    async writeToDisk() {
+        if (!this.persistPath)
+            return;
+        const lines = [...this.tasks.values()].map((t) => JSON.stringify(t)).join('\n');
+        await fs.writeFile(this.persistPath, lines ? lines + '\n' : '', 'utf8');
+    }
+    // ---------------------------------------------------------------------------
+    // ID generation
+    // ---------------------------------------------------------------------------
+    generateId() {
+        this.counter++;
+        return `${this.prefix}-${String(this.counter).padStart(3, '0')}`;
+    }
+    // ---------------------------------------------------------------------------
+    // Reads
+    // ---------------------------------------------------------------------------
+    /** Return the task with the given ID, or `undefined` if not found. */
+    get(id) {
+        return this.tasks.get(id);
+    }
+    /**
+     * List tasks matching the given filters.
+     *
+     * - Default (no `status`): excludes closed tasks.
+     * - `status: 'all'`: returns all tasks regardless of status.
+     * - `status: <value>`: returns only tasks with that status.
+     * - `label`: further filter by a label string.
+     * - `limit`: cap the number of results (0 or omitted = no cap).
+     */
+    list(params = {}) {
+        let results = [...this.tasks.values()];
+        if (params.status === 'all') {
+            // no status filter
+        }
+        else if (params.status) {
+            results = results.filter((t) => t.status === params.status);
+        }
+        else {
+            results = results.filter((t) => t.status !== 'closed');
+        }
+        if (params.label) {
+            const label = params.label;
+            results = results.filter((t) => t.labels?.includes(label));
+        }
+        if (params.limit != null && params.limit > 0) {
+            results = results.slice(0, params.limit);
+        }
+        return results;
+    }
+    /**
+     * Find a non-closed task whose title matches the given string
+     * (case-insensitive, trimmed). Optionally filter by label.
+     * Returns the first match, or null if none found.
+     */
+    findByTitle(title, opts) {
+        const normalized = title.trim().toLowerCase();
+        if (!normalized)
+            return null;
+        const candidates = opts?.label ? this.list({ label: opts.label }) : this.list();
+        const match = candidates.find((t) => t.status !== 'closed' && t.title.trim().toLowerCase() === normalized);
+        return match ?? null;
+    }
+    /** Total number of tasks in the store (all statuses). */
+    size() {
+        return this.tasks.size;
+    }
+    // ---------------------------------------------------------------------------
+    // Writes (synchronous in-memory; async persist)
+    // ---------------------------------------------------------------------------
+    /** Create a new task. Emits `"created"` synchronously. */
+    create(params) {
+        const now = new Date().toISOString();
+        const task = {
+            id: this.generateId(),
+            title: params.title,
+            status: 'open',
+            ...(params.description !== undefined && { description: params.description }),
+            ...(params.priority !== undefined && { priority: params.priority }),
+            ...(params.issueType !== undefined && { issue_type: params.issueType }),
+            ...(params.owner !== undefined && { owner: params.owner }),
+            ...(params.labels?.length && { labels: [...params.labels] }),
+            created_at: now,
+            updated_at: now,
+        };
+        this.tasks.set(task.id, task);
+        this.emit('created', task);
+        this.schedulePersist();
+        return task;
+    }
+    /** Update fields on an existing task. Emits `"updated"` synchronously. */
+    update(id, params) {
+        const prev = this.tasks.get(id);
+        if (!prev)
+            throw new Error(`task not found: ${id}`);
+        const now = new Date().toISOString();
+        const updated = {
+            ...prev,
+            ...(params.title !== undefined && { title: params.title }),
+            ...(params.description !== undefined && { description: params.description }),
+            ...(params.priority !== undefined && { priority: params.priority }),
+            ...(params.status !== undefined && { status: params.status }),
+            ...(params.owner !== undefined && { owner: params.owner }),
+            ...(params.externalRef !== undefined && { external_ref: params.externalRef }),
+            updated_at: now,
+        };
+        this.tasks.set(id, updated);
+        this.emit('updated', updated, prev);
+        this.schedulePersist();
+        return updated;
+    }
+    /** Close a task. Emits `"closed"` synchronously. */
+    close(id, reason) {
+        const prev = this.tasks.get(id);
+        if (!prev)
+            throw new Error(`task not found: ${id}`);
+        const now = new Date().toISOString();
+        const closed = {
+            ...prev,
+            status: 'closed',
+            closed_at: now,
+            updated_at: now,
+            ...(reason !== undefined && { close_reason: reason }),
+        };
+        this.tasks.set(id, closed);
+        this.emit('closed', closed);
+        this.schedulePersist();
+        return closed;
+    }
+    /** Add a label to a task. No-op (returns existing task) if already present. Emits `"labeled"` synchronously. */
+    addLabel(id, label) {
+        const prev = this.tasks.get(id);
+        if (!prev)
+            throw new Error(`task not found: ${id}`);
+        if (prev.labels?.includes(label))
+            return prev;
+        const now = new Date().toISOString();
+        const updated = {
+            ...prev,
+            labels: [...(prev.labels ?? []), label],
+            updated_at: now,
+        };
+        this.tasks.set(id, updated);
+        this.emit('labeled', updated, label);
+        this.schedulePersist();
+        return updated;
+    }
+    /** Remove a label from a task. No-op (returns existing task) if label is absent. Emits `"updated"` synchronously. */
+    removeLabel(id, label) {
+        const prev = this.tasks.get(id);
+        if (!prev)
+            throw new Error(`task not found: ${id}`);
+        if (!prev.labels?.includes(label))
+            return prev;
+        const now = new Date().toISOString();
+        const updated = {
+            ...prev,
+            labels: prev.labels.filter((l) => l !== label),
+            updated_at: now,
+        };
+        this.tasks.set(id, updated);
+        this.emit('updated', updated, prev);
+        this.schedulePersist();
+        return updated;
+    }
+}