discoclaw 0.1.0

package/dist/tasks/discord-types.js

@@ -0,0 +1,4 @@
+import { ChannelType, GatewayIntentBits, Client as DiscordClient } from 'discord.js';
+export const TaskDiscordChannelType = ChannelType;
+export const TaskDiscordGatewayIntentBits = GatewayIntentBits;
+export const TaskDiscordClientCtor = DiscordClient;

package/dist/tasks/find-task-by-thread.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { TaskStore } from './store.js';
+import { findTaskByThreadId } from './thread-cache.js';
+function makeStore(externalRefs) {
+    const store = new TaskStore({ prefix: 'ws' });
+    for (const externalRef of externalRefs) {
+        const b = store.create({ title: 'Test' });
+        store.update(b.id, { externalRef });
+    }
+    return store;
+}
+describe('findTaskByThreadId', () => {
+    it('returns task when external_ref matches as discord:<threadId>', () => {
+        const store = makeStore([
+            'discord:111222333444555666',
+            'discord:999888777666555444',
+        ]);
+        const result = findTaskByThreadId('111222333444555666', store);
+        expect(result?.id).toBe('ws-001');
+    });
+    it('returns task when external_ref is raw numeric ID', () => {
+        const store = makeStore(['111222333444555666']);
+        const result = findTaskByThreadId('111222333444555666', store);
+        expect(result?.id).toBe('ws-001');
+    });
+    it('returns null when no match', () => {
+        const store = makeStore(['discord:999888777666555444']);
+        const result = findTaskByThreadId('111222333444555666', store);
+        expect(result).toBeNull();
+    });
+    it('returns null when store is empty', () => {
+        const store = new TaskStore();
+        const result = findTaskByThreadId('111222333444555666', store);
+        expect(result).toBeNull();
+    });
+});

package/dist/tasks/forum-guard.js

@@ -0,0 +1,81 @@
+import { findTaskByThreadId } from './thread-cache.js';
+import { buildAppliedTagsWithStatus, buildThreadName } from './thread-helpers.js';
+function isBotOwned(thread) {
+    const botUserId = thread.client?.user?.id ?? '';
+    return botUserId !== '' && thread.ownerId === botUserId;
+}
+async function rejectManualThread(thread, log) {
+    log?.info({ threadId: thread.id, name: thread.name, ownerId: thread.ownerId }, 'tasks:forum rejected manual thread');
+    try {
+        await thread.send('Tasks must be created using bot commands or the `bd` CLI, not by manually creating forum threads.\n\n'
+            + 'Ask the bot to create a task for you, or run `bd create` from the terminal.\n\n'
+            + 'This thread will be archived.');
+    }
+    catch { /* ignore */ }
+    try {
+        await thread.setArchived(true);
+    }
+    catch { /* ignore */ }
+}
+async function reArchiveTaskThread(thread, store, tagMap, log) {
+    let task;
+    try {
+        task = findTaskByThreadId(thread.id, store);
+    }
+    catch {
+        return false;
+    }
+    if (!task)
+        return false;
+    log?.info({ threadId: thread.id, taskId: task.id }, 'tasks:forum re-archiving known task thread');
+    try {
+        const current = thread.appliedTags ?? [];
+        const updated = buildAppliedTagsWithStatus(current, task.status, tagMap);
+        const name = buildThreadName(task.id, task.title, task.status);
+        await thread.edit({ name, appliedTags: updated });
+    }
+    catch { /* ignore — proceed to archive */ }
+    try {
+        await thread.setArchived(true);
+    }
+    catch { /* ignore */ }
+    return true;
+}
+export function initTasksForumGuard(opts) {
+    const { client, forumId, log, store, tagMap } = opts;
+    client.on('threadCreate', async (thread) => {
+        try {
+            if (thread.parentId !== forumId)
+                return;
+            if (isBotOwned(thread))
+                return;
+            if (store && tagMap) {
+                if (await reArchiveTaskThread(thread, store, tagMap, log))
+                    return;
+            }
+            await rejectManualThread(thread, log);
+        }
+        catch (err) {
+            log?.error({ err, threadId: thread.id }, 'tasks:forum threadCreate guard failed');
+        }
+    });
+    client.on('threadUpdate', async (_oldThread, newThread) => {
+        try {
+            if (newThread.parentId !== forumId)
+                return;
+            // Only act on unarchive transitions.
+            if (newThread.archived)
+                return;
+            if (isBotOwned(newThread))
+                return;
+            if (store && tagMap) {
+                if (await reArchiveTaskThread(newThread, store, tagMap, log))
+                    return;
+            }
+            await rejectManualThread(newThread, log);
+        }
+        catch (err) {
+            log?.error({ err, threadId: newThread.id }, 'tasks:forum threadUpdate guard failed');
+        }
+    });
+}

package/dist/tasks/forum-guard.test.js

@@ -0,0 +1,192 @@
+import { describe, expect, it, vi } from 'vitest';
+import { TaskStore } from './store.js';
+import { initTasksForumGuard } from './forum-guard.js';
+vi.mock('./thread-cache.js', () => ({
+    findTaskByThreadId: vi.fn(),
+}));
+vi.mock('./thread-helpers.js', () => ({
+    buildAppliedTagsWithStatus: vi.fn(() => ['tag-closed']),
+    buildThreadName: vi.fn(() => '✅ [001] My Task'),
+}));
+import { findTaskByThreadId } from './thread-cache.js';
+function makeClient(botUserId = 'bot-user-1') {
+    const listeners = {};
+    return {
+        on: vi.fn((event, cb) => {
+            (listeners[event] ??= []).push(cb);
+        }),
+        user: { id: botUserId },
+        _listeners: listeners,
+    };
+}
+function makeThread(overrides) {
+    return {
+        id: 'thread-1',
+        name: 'Task 1',
+        parentId: 'tasks-forum-1',
+        ownerId: 'bot-user-1',
+        appliedTags: [],
+        send: vi.fn().mockResolvedValue(undefined),
+        setArchived: vi.fn().mockResolvedValue(undefined),
+        setName: vi.fn().mockResolvedValue(undefined),
+        edit: vi.fn().mockResolvedValue(undefined),
+        client: { user: { id: 'bot-user-1' } },
+        ...overrides,
+    };
+}
+const MOCK_TASK = { id: 'ws-001', title: 'My Task', status: 'closed' };
+describe('initTasksForumGuard', () => {
+    function setup(botUserId = 'bot-user-1') {
+        const client = makeClient(botUserId);
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        initTasksForumGuard({ client: client, forumId: 'tasks-forum-1', log });
+        const listeners = client._listeners['threadCreate'] ?? [];
+        expect(listeners.length).toBeGreaterThan(0);
+        return { listener: listeners[0], log };
+    }
+    it('rejects manually-created threads with guidance and archives', async () => {
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('allows bot-created threads through without sending or archiving', async () => {
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'bot-user-1' });
+        await listener(thread);
+        expect(thread.send).not.toHaveBeenCalled();
+        expect(thread.setArchived).not.toHaveBeenCalled();
+    });
+    it('ignores threads from other forums', async () => {
+        const { listener } = setup();
+        const thread = makeThread({ parentId: 'other-forum', ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).not.toHaveBeenCalled();
+        expect(thread.setArchived).not.toHaveBeenCalled();
+    });
+    it('handles send failure without preventing archive attempt', async () => {
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        thread.send.mockRejectedValue(new Error('Missing Access'));
+        await listener(thread);
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+});
+describe('initTasksForumGuard threadUpdate', () => {
+    function setup(botUserId = 'bot-user-1') {
+        const client = makeClient(botUserId);
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        initTasksForumGuard({ client: client, forumId: 'tasks-forum-1', log });
+        const listeners = client._listeners['threadUpdate'] ?? [];
+        expect(listeners.length).toBeGreaterThan(0);
+        return { listener: listeners[0], log };
+    }
+    it('rejects unarchived manual thread', async () => {
+        const { listener } = setup();
+        const oldThread = makeThread({ ownerId: 'some-user', archived: true });
+        const newThread = makeThread({ ownerId: 'some-user', archived: false });
+        await listener(oldThread, newThread);
+        expect(newThread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(newThread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('allows bot-owned unarchived thread through', async () => {
+        const { listener } = setup();
+        const oldThread = makeThread({ archived: true });
+        const newThread = makeThread({ archived: false });
+        await listener(oldThread, newThread);
+        expect(newThread.send).not.toHaveBeenCalled();
+        expect(newThread.setArchived).not.toHaveBeenCalled();
+    });
+    it('ignores archive transitions (thread being archived)', async () => {
+        const { listener } = setup();
+        const oldThread = makeThread({ ownerId: 'some-user', archived: false });
+        const newThread = makeThread({ ownerId: 'some-user', archived: true });
+        await listener(oldThread, newThread);
+        expect(newThread.send).not.toHaveBeenCalled();
+    });
+});
+describe('initTasksForumGuard task-aware re-archive (threadCreate)', () => {
+    function setup() {
+        const client = makeClient();
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        initTasksForumGuard({
+            client: client,
+            forumId: 'tasks-forum-1',
+            log,
+            store: new TaskStore(),
+            tagMap: { closed: 'tag-closed' },
+        });
+        const listener = (client._listeners['threadCreate'] ?? [])[0];
+        return { listener, log };
+    }
+    it('re-archives known task thread without sending rejection message', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(MOCK_TASK);
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).not.toHaveBeenCalled();
+        expect(thread.edit).toHaveBeenCalledWith({ name: '✅ [001] My Task', appliedTags: ['tag-closed'] });
+        expect(thread.setName).not.toHaveBeenCalled();
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('falls through to rejection when task lookup returns null', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(null);
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('falls through to rejection when task lookup throws', async () => {
+        vi.mocked(findTaskByThreadId).mockImplementation(() => { throw new Error('fs error'); });
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        await listener(thread);
+        expect(thread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('still archives even when edit throws', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(MOCK_TASK);
+        const { listener } = setup();
+        const thread = makeThread({ ownerId: 'some-user' });
+        thread.edit.mockRejectedValue(new Error('edit failed'));
+        await listener(thread);
+        expect(thread.setArchived).toHaveBeenCalledWith(true);
+    });
+});
+describe('initTasksForumGuard task-aware re-archive (threadUpdate)', () => {
+    function setup() {
+        const client = makeClient();
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        initTasksForumGuard({
+            client: client,
+            forumId: 'tasks-forum-1',
+            log,
+            store: new TaskStore(),
+            tagMap: { closed: 'tag-closed' },
+        });
+        const listener = (client._listeners['threadUpdate'] ?? [])[0];
+        return { listener, log };
+    }
+    it('re-archives known task thread on unarchive without rejection message', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(MOCK_TASK);
+        const { listener } = setup();
+        const oldThread = makeThread({ ownerId: 'some-user', archived: true });
+        const newThread = makeThread({ ownerId: 'some-user', archived: false });
+        await listener(oldThread, newThread);
+        expect(newThread.send).not.toHaveBeenCalled();
+        expect(newThread.edit).toHaveBeenCalledWith({ name: '✅ [001] My Task', appliedTags: ['tag-closed'] });
+        expect(newThread.setName).not.toHaveBeenCalled();
+        expect(newThread.setArchived).toHaveBeenCalledWith(true);
+    });
+    it('falls through to rejection when task not found on threadUpdate', async () => {
+        vi.mocked(findTaskByThreadId).mockReturnValue(null);
+        const { listener } = setup();
+        const oldThread = makeThread({ ownerId: 'some-user', archived: true });
+        const newThread = makeThread({ ownerId: 'some-user', archived: false });
+        await listener(oldThread, newThread);
+        expect(newThread.send).toHaveBeenCalledWith(expect.stringContaining('bd create'));
+        expect(newThread.setArchived).toHaveBeenCalledWith(true);
+    });
+});

package/dist/tasks/initialize.js

@@ -0,0 +1,77 @@
+import { createTaskService } from './service.js';
+import { ensureTaskSyncCoordinator, wireTaskStoreSyncTriggers } from './task-sync.js';
+import { TASK_SYNC_TRIGGER_EVENTS } from './sync-contract.js';
+import { loadTagMap } from './tag-map.js';
+// ---------------------------------------------------------------------------
+// Core initialization (no Discord client — context only)
+// ---------------------------------------------------------------------------
+/**
+ * Build a TaskContext if prerequisites are met, or return undefined with
+ * appropriate log warnings. This covers the "pre-bot" phase — before the
+ * Discord client is available. Forum guard and sync trigger subscriptions are wired
+ * separately after the bot connects.
+ */
+export async function initializeTasksContext(opts) {
+    if (!opts.enabled) {
+        return { taskCtx: undefined };
+    }
+    const effectiveForum = opts.systemTasksForumId || opts.tasksForum || '';
+    if (!effectiveForum) {
+        opts.log.warn('tasks: no forum resolved — set DISCORD_GUILD_ID or DISCOCLAW_TASKS_FORUM ' +
+            '(set DISCOCLAW_TASKS_ENABLED=0 to suppress)');
+        return { taskCtx: undefined };
+    }
+    const tagMapPath = opts.tasksTagMapPath || '';
+    const tagMap = await loadTagMap(tagMapPath);
+    const tasksSidebar = opts.tasksSidebar ?? false;
+    const tasksMentionUser = opts.tasksMentionUser;
+    const sidebarMentionUserId = tasksSidebar ? tasksMentionUser : undefined;
+    if (tasksSidebar && !tasksMentionUser) {
+        opts.log.warn('tasks:sidebar enabled but DISCOCLAW_TASKS_MENTION_USER not set; sidebar mentions will be inactive');
+    }
+    let store = opts.store;
+    if (!store) {
+        const { TaskStore } = await import('./store.js');
+        store = new TaskStore();
+    }
+    const taskCtx = {
+        tasksCwd: opts.tasksCwd || process.cwd(),
+        forumId: effectiveForum,
+        tagMap,
+        tagMapPath,
+        store,
+        taskService: createTaskService(store),
+        runtime: opts.runtime,
+        resolveModel: opts.resolveModel,
+        autoTag: opts.tasksAutoTag ?? true,
+        autoTagModel: opts.tasksAutoTagModel ?? 'fast',
+        mentionUserId: tasksMentionUser,
+        sidebarMentionUserId,
+        statusPoster: opts.statusPoster,
+        hasInFlightForChannel: opts.hasInFlightForChannel,
+        metrics: opts.metrics,
+        log: opts.log,
+        syncFailureRetryEnabled: opts.tasksSyncFailureRetryEnabled,
+        syncFailureRetryDelayMs: opts.tasksSyncFailureRetryDelayMs,
+        syncDeferredRetryDelayMs: opts.tasksSyncDeferredRetryDelayMs,
+        syncRunOptions: opts.syncRunOptions,
+    };
+    return { taskCtx };
+}
+// ---------------------------------------------------------------------------
+// Post-connect wiring (store event subscriptions + startup sync)
+// ---------------------------------------------------------------------------
+export async function wireTaskSync(taskCtx, runCtx) {
+    const log = taskCtx.log;
+    if (!log) {
+        throw new Error('wireTaskSync requires taskCtx.log');
+    }
+    const syncCoordinator = await ensureTaskSyncCoordinator(taskCtx, runCtx);
+    // Startup sync: fire-and-forget to avoid blocking cron init
+    syncCoordinator.sync().catch((err) => {
+        log.warn({ err }, 'tasks:startup-sync failed');
+    });
+    const wiring = wireTaskStoreSyncTriggers(taskCtx, syncCoordinator, log);
+    log.info({ tasksCwd: taskCtx.tasksCwd, triggerEvents: TASK_SYNC_TRIGGER_EVENTS }, 'tasks:store-event sync triggers started');
+    return wiring;
+}

package/dist/tasks/initialize.test.js

@@ -0,0 +1,263 @@
+import { describe, expect, it, vi } from 'vitest';
+// ---------------------------------------------------------------------------
+// Module mocks
+// ---------------------------------------------------------------------------
+vi.mock('./tag-map.js', () => ({
+    loadTagMap: vi.fn().mockResolvedValue({ bug: '111', feature: '222' }),
+}));
+vi.mock('./sync-coordinator.js', () => ({
+    TaskSyncCoordinator: vi.fn().mockImplementation(() => ({
+        sync: vi.fn().mockResolvedValue(undefined),
+    })),
+}));
+import { TaskSyncCoordinator } from './sync-coordinator.js';
+import { initializeTasksContext, wireTaskSync } from './initialize.js';
+import { TaskStore } from './store.js';
+import { withDirectTaskLifecycle } from './task-lifecycle.js';
+function fakeLog() {
+    return {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    };
+}
+function baseOpts(overrides = {}) {
+    return {
+        enabled: true,
+        tasksCwd: '/tmp/tasks',
+        tasksForum: 'forum-123',
+        tasksTagMapPath: '/tmp/tag-map.json',
+        tasksSidebar: false,
+        tasksAutoTag: true,
+        tasksAutoTagModel: 'haiku',
+        runtime: {},
+        resolveModel: (model) => model,
+        log: fakeLog(),
+        ...overrides,
+    };
+}
+describe('initializeTasksContext', () => {
+    it('returns undefined with no warnings when disabled', async () => {
+        const log = fakeLog();
+        const result = await initializeTasksContext(baseOpts({ enabled: false, log }));
+        expect(result.taskCtx).toBeUndefined();
+        expect(log.warn).not.toHaveBeenCalled();
+    });
+    it('returns undefined and warns when no forum resolved', async () => {
+        const log = fakeLog();
+        const result = await initializeTasksContext(baseOpts({
+            tasksForum: '',
+            systemTasksForumId: undefined,
+            log,
+        }));
+        expect(result.taskCtx).toBeUndefined();
+        expect(log.warn).toHaveBeenCalledWith(expect.stringContaining('no forum resolved'));
+    });
+    it('returns TaskContext when all prerequisites met', async () => {
+        const log = fakeLog();
+        const result = await initializeTasksContext(baseOpts({ log }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.forumId).toBe('forum-123');
+        expect(result.taskCtx.autoTag).toBe(true);
+    });
+    it('resolves forum from systemTasksForumId when tasksForum is empty', async () => {
+        const result = await initializeTasksContext(baseOpts({
+            tasksForum: '',
+            systemTasksForumId: 'system-forum-456',
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.forumId).toBe('system-forum-456');
+    });
+    it('sets sidebarMentionUserId when sidebar enabled with mention user', async () => {
+        const log = fakeLog();
+        const result = await initializeTasksContext(baseOpts({
+            tasksSidebar: true,
+            tasksMentionUser: 'user-789',
+            log,
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.sidebarMentionUserId).toBe('user-789');
+        expect(log.warn).not.toHaveBeenCalled();
+    });
+    it('warns when sidebar enabled but mention user not set', async () => {
+        const log = fakeLog();
+        const result = await initializeTasksContext(baseOpts({
+            tasksSidebar: true,
+            tasksMentionUser: undefined,
+            log,
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.sidebarMentionUserId).toBeUndefined();
+        expect(log.warn).toHaveBeenCalledWith(expect.stringContaining('sidebar mentions will be inactive'));
+    });
+    it('does not set sidebarMentionUserId when sidebar disabled', async () => {
+        const log = fakeLog();
+        const result = await initializeTasksContext(baseOpts({
+            tasksSidebar: false,
+            tasksMentionUser: 'user-789',
+            log,
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.sidebarMentionUserId).toBeUndefined();
+        expect(log.warn).not.toHaveBeenCalled();
+    });
+    it('propagates tagMapPath to TaskContext', async () => {
+        const result = await initializeTasksContext(baseOpts({
+            tasksTagMapPath: '/my/custom/tag-map.json',
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.tagMapPath).toBe('/my/custom/tag-map.json');
+    });
+    it('stores sync run options on TaskContext', async () => {
+        const result = await initializeTasksContext(baseOpts({
+            syncRunOptions: { skipPhase5: true },
+        }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.syncRunOptions).toEqual({ skipPhase5: true });
+    });
+    it('uses provided store instead of creating a new one', async () => {
+        const store = new TaskStore();
+        const result = await initializeTasksContext(baseOpts({ store }));
+        expect(result.taskCtx).toBeDefined();
+        expect(result.taskCtx.store).toBe(store);
+    });
+});
+describe('wireTaskSync', () => {
+    it('wires coordinator and store event listeners', async () => {
+        const log = fakeLog();
+        const store = new TaskStore();
+        const taskCtx = {
+            tasksCwd: '/tmp/tasks',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            sidebarMentionUserId: 'user-1',
+            store,
+            syncFailureRetryEnabled: false,
+            syncFailureRetryDelayMs: 12_000,
+            syncDeferredRetryDelayMs: 18_000,
+            log,
+        };
+        const client = {};
+        const guild = {};
+        const result = await wireTaskSync(taskCtx, { client, guild });
+        expect(TaskSyncCoordinator).toHaveBeenCalledWith(expect.objectContaining({
+            client,
+            guild,
+            forumId: 'forum-123',
+            mentionUserId: 'user-1',
+            enableFailureRetry: false,
+            failureRetryDelayMs: 12_000,
+            deferredRetryDelayMs: 18_000,
+        }));
+        // The coordinator's sync() should have been called (fire-and-forget startup sync).
+        const coordinatorInstance = vi.mocked(TaskSyncCoordinator).mock.results[0]?.value;
+        expect(coordinatorInstance.sync).toHaveBeenCalled();
+        expect(taskCtx.syncCoordinator).toBeDefined();
+        expect(result).toHaveProperty('stop');
+        expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ tasksCwd: '/tmp/tasks' }), 'tasks:store-event sync triggers started');
+    });
+    it('store events trigger coordinator sync', async () => {
+        const log = fakeLog();
+        const store = new TaskStore({ prefix: 'test' });
+        const taskCtx = {
+            tasksCwd: '/tmp/tasks',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            tagMapPath: '/tmp/tag-map.json',
+            store,
+            log,
+        };
+        vi.mocked(TaskSyncCoordinator).mockClear();
+        await wireTaskSync(taskCtx, { client: {}, guild: {} });
+        const coordinatorInstance = vi.mocked(TaskSyncCoordinator).mock.results[0]?.value;
+        // 'created' is intentionally NOT wired — taskCreate handles thread creation directly.
+        const callsBeforeCreate = coordinatorInstance.sync.mock.calls.length;
+        const task = store.create({ title: 'Test task' });
+        expect(coordinatorInstance.sync.mock.calls.length).toBe(callsBeforeCreate);
+        // 'updated' IS wired — should trigger sync.
+        const callsBeforeUpdate = coordinatorInstance.sync.mock.calls.length;
+        store.update(task.id, { title: 'Updated task' });
+        expect(coordinatorInstance.sync.mock.calls.length).toBeGreaterThan(callsBeforeUpdate);
+    });
+    it('does not trigger coordinator sync while direct task lifecycle ownership is active', async () => {
+        const log = fakeLog();
+        const store = new TaskStore({ prefix: 'test' });
+        const taskCtx = {
+            tasksCwd: '/tmp/tasks',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            tagMapPath: '/tmp/tag-map.json',
+            store,
+            log,
+        };
+        vi.mocked(TaskSyncCoordinator).mockClear();
+        await wireTaskSync(taskCtx, { client: {}, guild: {} });
+        const coordinatorInstance = vi.mocked(TaskSyncCoordinator).mock.results[0]?.value;
+        const task = store.create({ title: 'Owned lifecycle task' });
+        const callsBeforeUpdate = coordinatorInstance.sync.mock.calls.length;
+        await withDirectTaskLifecycle(task.id, async () => {
+            store.update(task.id, { title: 'Updated while owned' });
+        });
+        expect(coordinatorInstance.sync.mock.calls.length).toBe(callsBeforeUpdate);
+    });
+    it('stop() removes store event listeners', async () => {
+        const log = fakeLog();
+        const store = new TaskStore({ prefix: 'test' });
+        const taskCtx = {
+            tasksCwd: '/tmp/tasks',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            tagMapPath: '/tmp/tag-map.json',
+            store,
+            log,
+        };
+        vi.mocked(TaskSyncCoordinator).mockClear();
+        const result = await wireTaskSync(taskCtx, { client: {}, guild: {} });
+        result.stop();
+        const coordinatorInstance = vi.mocked(TaskSyncCoordinator).mock.results[0]?.value;
+        const callsAfterStop = coordinatorInstance.sync.mock.calls.length;
+        // After stop(), store mutations should NOT trigger additional syncs
+        const task = store.create({ title: 'Another task' });
+        store.update(task.id, { title: 'Modified' });
+        expect(coordinatorInstance.sync.mock.calls.length).toBe(callsAfterStop);
+    });
+    it('propagates tagMapPath to CoordinatorOptions', async () => {
+        const log = fakeLog();
+        const tagMap = { bug: '111' };
+        const store = new TaskStore();
+        const taskCtx = {
+            tasksCwd: '/tmp/tasks',
+            forumId: 'forum-123',
+            tagMap,
+            tagMapPath: '/config/tag-map.json',
+            store,
+            log,
+        };
+        await wireTaskSync(taskCtx, { client: {}, guild: {} });
+        expect(TaskSyncCoordinator).toHaveBeenCalledWith(expect.objectContaining({
+            tagMapPath: '/config/tag-map.json',
+            tagMap,
+        }));
+    });
+    it('uses TaskContext sync retry configuration in CoordinatorOptions', async () => {
+        const log = fakeLog();
+        const store = new TaskStore();
+        const taskCtx = {
+            tasksCwd: '/tmp/tasks',
+            forumId: 'forum-123',
+            tagMap: { bug: '111' },
+            syncFailureRetryEnabled: false,
+            syncFailureRetryDelayMs: 12_000,
+            syncDeferredRetryDelayMs: 18_000,
+            store,
+            log,
+        };
+        vi.mocked(TaskSyncCoordinator).mockClear();
+        await wireTaskSync(taskCtx, { client: {}, guild: {} });
+        expect(TaskSyncCoordinator).toHaveBeenCalledWith(expect.objectContaining({
+            enableFailureRetry: false,
+            failureRetryDelayMs: 12_000,
+            deferredRetryDelayMs: 18_000,
+        }));
+    });
+});

package/dist/tasks/logger-types.js

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

package/dist/tasks/metrics-types.js

@@ -0,0 +1,3 @@
+export const noopTaskMetrics = {
+    increment() { },
+};