discoclaw 0.1.0

package/dist/tasks/sync-watcher.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+import { startTaskSyncWatcher } from './sync-watcher.js';
+function makeCoordinator() {
+    return {
+        sync: vi.fn(async () => ({
+            threadsCreated: 0,
+            emojisUpdated: 0,
+            starterMessagesUpdated: 0,
+            threadsArchived: 0,
+            statusesUpdated: 0,
+            tagsUpdated: 0,
+            warnings: 0,
+        })),
+    };
+}
+function makeStore() {
+    return new EventEmitter();
+}
+describe('startTaskSyncWatcher', () => {
+    it('triggers sync on store created event', async () => {
+        const coordinator = makeCoordinator();
+        const store = makeStore();
+        const handle = startTaskSyncWatcher({ coordinator, store });
+        store.emit('created', {});
+        await Promise.resolve();
+        expect(coordinator.sync).toHaveBeenCalledOnce();
+        expect(coordinator.sync).toHaveBeenCalledWith();
+        handle.stop();
+    });
+    it('triggers sync on store updated event', async () => {
+        const coordinator = makeCoordinator();
+        const store = makeStore();
+        const handle = startTaskSyncWatcher({ coordinator, store });
+        store.emit('updated', {}, {});
+        await Promise.resolve();
+        expect(coordinator.sync).toHaveBeenCalledOnce();
+        handle.stop();
+    });
+    it('triggers sync on store closed event', async () => {
+        const coordinator = makeCoordinator();
+        const store = makeStore();
+        const handle = startTaskSyncWatcher({ coordinator, store });
+        store.emit('closed', {});
+        await Promise.resolve();
+        expect(coordinator.sync).toHaveBeenCalledOnce();
+        handle.stop();
+    });
+    it('triggers sync on store labeled event', async () => {
+        const coordinator = makeCoordinator();
+        const store = makeStore();
+        const handle = startTaskSyncWatcher({ coordinator, store });
+        store.emit('labeled', {}, 'some-label');
+        await Promise.resolve();
+        expect(coordinator.sync).toHaveBeenCalledOnce();
+        handle.stop();
+    });
+    it('no sync fires after stop()', async () => {
+        const coordinator = makeCoordinator();
+        const store = makeStore();
+        const handle = startTaskSyncWatcher({ coordinator, store });
+        handle.stop();
+        store.emit('created', {});
+        await Promise.resolve();
+        expect(coordinator.sync).not.toHaveBeenCalled();
+    });
+    it('multiple events each trigger a sync call (coordinator coalesces)', async () => {
+        const coordinator = makeCoordinator();
+        const store = makeStore();
+        const handle = startTaskSyncWatcher({ coordinator, store });
+        store.emit('created', {});
+        store.emit('updated', {}, {});
+        store.emit('closed', {});
+        await Promise.resolve();
+        // Each event fires a sync; the coordinator's concurrency guard coalesces them.
+        expect(coordinator.sync).toHaveBeenCalledTimes(3);
+        handle.stop();
+    });
+    it('sync failure is caught and logged without throwing', async () => {
+        const coordinator = {
+            sync: vi.fn().mockRejectedValue(new Error('network error')),
+        };
+        const store = makeStore();
+        const log = { warn: vi.fn(), info: vi.fn(), error: vi.fn() };
+        const handle = startTaskSyncWatcher({ coordinator, store, log });
+        store.emit('created', {});
+        // Flush the microtask queue so the catch handler runs.
+        await new Promise((r) => setTimeout(r, 0));
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ err: expect.any(Error) }), 'tasks:watcher sync failed');
+        handle.stop();
+    });
+});

package/dist/tasks/tag-map.js

@@ -0,0 +1,36 @@
+import fs from 'node:fs/promises';
+/** Load a tag-map.json file: `{ "tag-name": "discord-tag-id", ... }`. */
+export async function loadTagMap(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Reload a tag-map.json file and mutate the existing TagMap object in-place.
+ * Unlike loadTagMap(), this throws on read/parse/validation failure so callers
+ * can catch and preserve the existing map. Only mutates after full validation.
+ * Returns the new tag count.
+ */
+export async function reloadTagMapInPlace(tagMapPath, tagMap) {
+    const raw = await fs.readFile(tagMapPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`tag-map.json must be a JSON object, got ${Array.isArray(parsed) ? 'array' : typeof parsed}`);
+    }
+    const newMap = {};
+    for (const [key, val] of Object.entries(parsed)) {
+        if (typeof val !== 'string') {
+            throw new Error(`tag-map.json value for "${key}" must be a string, got ${typeof val}`);
+        }
+        newMap[key] = val;
+    }
+    // Only mutate after full validation.
+    for (const key of Object.keys(tagMap))
+        delete tagMap[key];
+    Object.assign(tagMap, newMap);
+    return Object.keys(tagMap).length;
+}

package/dist/tasks/tag-map.test.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs/promises';
+import { describe, expect, it, vi } from 'vitest';
+import { loadTagMap, reloadTagMapInPlace } from './tag-map.js';
+describe('loadTagMap', () => {
+    it('returns parsed tag map when file is valid', async () => {
+        vi.spyOn(fs, 'readFile').mockResolvedValueOnce(JSON.stringify({ bug: '111', feature: '222' }));
+        const result = await loadTagMap('/tmp/tag-map.json');
+        expect(result).toEqual({ bug: '111', feature: '222' });
+    });
+    it('returns empty map when file is missing', async () => {
+        vi.spyOn(fs, 'readFile').mockRejectedValueOnce(new Error('ENOENT'));
+        const result = await loadTagMap('/tmp/missing.json');
+        expect(result).toEqual({});
+    });
+    it('returns empty map when JSON is invalid', async () => {
+        vi.spyOn(fs, 'readFile').mockResolvedValueOnce('{ bad json');
+        const result = await loadTagMap('/tmp/bad.json');
+        expect(result).toEqual({});
+    });
+});
+describe('reloadTagMapInPlace', () => {
+    it('reads file, mutates object in-place, and returns count', async () => {
+        vi.spyOn(fs, 'readFile').mockResolvedValueOnce(JSON.stringify({ bug: '111', feature: '222' }));
+        const tagMap = { old: '000' };
+        const count = await reloadTagMapInPlace('/tmp/tag-map.json', tagMap);
+        expect(count).toBe(2);
+        expect(tagMap).toEqual({ bug: '111', feature: '222' });
+        expect(tagMap).not.toHaveProperty('old');
+    });
+    it('throws on read failure, existing map untouched', async () => {
+        vi.spyOn(fs, 'readFile').mockRejectedValueOnce(new Error('ENOENT'));
+        const tagMap = { existing: '999' };
+        await expect(reloadTagMapInPlace('/tmp/missing.json', tagMap)).rejects.toThrow('ENOENT');
+        expect(tagMap).toEqual({ existing: '999' });
+    });
+    it('throws on truncated JSON, existing map untouched', async () => {
+        vi.spyOn(fs, 'readFile').mockResolvedValueOnce('{ "bug": "111"');
+        const tagMap = { existing: '999' };
+        await expect(reloadTagMapInPlace('/tmp/bad.json', tagMap)).rejects.toThrow();
+        expect(tagMap).toEqual({ existing: '999' });
+    });
+    it('rejects array with descriptive error, existing map untouched', async () => {
+        vi.spyOn(fs, 'readFile').mockResolvedValueOnce('["a", "b"]');
+        const tagMap = { existing: '999' };
+        await expect(reloadTagMapInPlace('/tmp/array.json', tagMap)).rejects.toThrow('must be a JSON object, got array');
+        expect(tagMap).toEqual({ existing: '999' });
+    });
+    it('rejects non-string values with descriptive error, existing map untouched', async () => {
+        vi.spyOn(fs, 'readFile').mockResolvedValueOnce(JSON.stringify({ bug: 123 }));
+        const tagMap = { existing: '999' };
+        await expect(reloadTagMapInPlace('/tmp/bad-val.json', tagMap)).rejects.toThrow('must be a string, got number');
+        expect(tagMap).toEqual({ existing: '999' });
+    });
+});

package/dist/tasks/task-action-contract.js

@@ -0,0 +1,16 @@
+const TASK_TYPE_MAP = {
+    taskCreate: true,
+    taskUpdate: true,
+    taskClose: true,
+    taskShow: true,
+    taskList: true,
+    taskSync: true,
+    tagMapReload: true,
+};
+export const TASK_ACTION_TYPES = new Set(Object.keys(TASK_TYPE_MAP));
+export function isTaskActionType(type) {
+    return TASK_ACTION_TYPES.has(type);
+}
+export function isTaskActionRequest(action) {
+    return typeof action.type === 'string' && isTaskActionType(action.type);
+}

package/dist/tasks/task-action-contract.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { isTaskActionRequest, isTaskActionType, TASK_ACTION_TYPES } from './task-action-contract.js';
+describe('task-action-contract guards', () => {
+    it('accepts canonical task action types', () => {
+        for (const type of TASK_ACTION_TYPES) {
+            expect(isTaskActionType(type)).toBe(true);
+        }
+    });
+    it('recognizes task action requests by type', () => {
+        expect(isTaskActionRequest({ type: 'taskCreate' })).toBe(true);
+        expect(isTaskActionRequest({ type: 'taskSync' })).toBe(true);
+        expect(isTaskActionRequest({ type: 'channelCreate' })).toBe(false);
+        expect(isTaskActionRequest({ type: 42 })).toBe(false);
+        expect(isTaskActionRequest({})).toBe(false);
+    });
+});

package/dist/tasks/task-action-executor.js

@@ -0,0 +1,18 @@
+import { handleTaskClose, handleTaskCreate, handleTaskUpdate, } from './task-action-mutations.js';
+import { handleTagMapReload, handleTaskList, handleTaskShow, handleTaskSync, } from './task-action-read-ops.js';
+const TASK_ACTION_HANDLERS = {
+    taskCreate: handleTaskCreate,
+    taskUpdate: handleTaskUpdate,
+    taskClose: handleTaskClose,
+    taskShow: handleTaskShow,
+    taskList: handleTaskList,
+    taskSync: handleTaskSync,
+    tagMapReload: handleTagMapReload,
+};
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+export async function executeTaskAction(action, ctx, taskCtx) {
+    const handler = TASK_ACTION_HANDLERS[action.type];
+    return handler(action, ctx, taskCtx);
+}

package/dist/tasks/task-action-executor.test.js

@@ -0,0 +1,420 @@
+import { describe, expect, it, vi } from 'vitest';
+import { TASK_ACTION_TYPES } from './task-action-contract.js';
+import { executeTaskAction } from './task-action-executor.js';
+import { taskActionsPromptSection } from './task-action-prompt.js';
+// ---------------------------------------------------------------------------
+// Mocks — override thread ops and related modules
+// ---------------------------------------------------------------------------
+vi.mock('./thread-ops.js', () => ({
+    resolveTasksForum: vi.fn(() => ({
+        threads: {
+            create: vi.fn(async () => ({ id: 'thread-new' })),
+        },
+    })),
+    createTaskThread: vi.fn(async () => 'thread-new'),
+    closeTaskThread: vi.fn(async () => { }),
+    updateTaskThreadName: vi.fn(async () => { }),
+    updateTaskStarterMessage: vi.fn(async () => true),
+    updateTaskThreadTags: vi.fn(async () => false),
+    ensureUnarchived: vi.fn(async () => { }),
+    findExistingThreadForTask: vi.fn(async () => null),
+}));
+vi.mock('./thread-helpers.js', () => ({
+    getThreadIdFromTask: vi.fn((task) => {
+        const ref = task.externalRef ?? task.external_ref ?? '';
+        if (ref.startsWith('discord:'))
+            return ref.slice('discord:'.length);
+        return null;
+    }),
+}));
+vi.mock('./tag-map.js', () => ({
+    reloadTagMapInPlace: vi.fn(async () => 2),
+}));
+vi.mock('./auto-tag.js', () => ({
+    autoTagTask: vi.fn(async () => ['feature']),
+}));
+vi.mock('./task-sync-engine.js', () => {
+    const runTaskSync = vi.fn(async () => ({
+        threadsCreated: 1,
+        emojisUpdated: 2,
+        starterMessagesUpdated: 5,
+        threadsArchived: 3,
+        statusesUpdated: 4,
+        tagsUpdated: 0,
+        warnings: 0,
+    }));
+    return { runTaskSync };
+});
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeCtx() {
+    return {
+        guild: {},
+        client: {
+            channels: {
+                cache: {
+                    get: () => undefined,
+                },
+            },
+        },
+    };
+}
+function makeStore() {
+    const defaultTask = (id) => ({
+        id,
+        title: 'Test task',
+        description: 'A test',
+        status: 'open',
+        priority: 2,
+        issue_type: 'task',
+        owner: '',
+        external_ref: 'discord:111222333',
+        labels: ['feature'],
+        comments: [],
+        created_at: '2026-01-01T00:00:00Z',
+        updated_at: '2026-01-01T00:00:00Z',
+    });
+    return {
+        get: vi.fn((id) => {
+            if (id === 'ws-notfound')
+                return undefined;
+            return defaultTask(id);
+        }),
+        list: vi.fn(() => [
+            { id: 'ws-001', title: 'First', status: 'open', priority: 2 },
+            { id: 'ws-002', title: 'Second', status: 'in_progress', priority: 1 },
+        ]),
+        create: vi.fn((params) => ({
+            id: 'ws-new',
+            title: params.title,
+            description: params.description ?? '',
+            status: 'open',
+            priority: params.priority ?? 2,
+            issue_type: 'task',
+            owner: '',
+            external_ref: '',
+            labels: params.labels ?? [],
+            comments: [],
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-01T00:00:00Z',
+        })),
+        update: vi.fn((id) => defaultTask(id)),
+        close: vi.fn((id) => ({ ...defaultTask(id), status: 'closed' })),
+        addLabel: vi.fn((id) => defaultTask(id)),
+    };
+}
+function makeTaskCtx(overrides) {
+    return {
+        tasksCwd: '/tmp/test-tasks',
+        forumId: 'forum-123',
+        tagMap: { feature: 'tag-1', bug: 'tag-2' },
+        store: makeStore(),
+        runtime: { id: 'other', capabilities: new Set(), invoke: async function* () { } },
+        autoTag: false,
+        autoTagModel: 'haiku',
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('TASK_ACTION_TYPES', () => {
+    it('contains all task action types', () => {
+        expect(TASK_ACTION_TYPES.has('taskCreate')).toBe(true);
+        expect(TASK_ACTION_TYPES.has('taskUpdate')).toBe(true);
+        expect(TASK_ACTION_TYPES.has('taskClose')).toBe(true);
+        expect(TASK_ACTION_TYPES.has('taskShow')).toBe(true);
+        expect(TASK_ACTION_TYPES.has('taskList')).toBe(true);
+        expect(TASK_ACTION_TYPES.has('taskSync')).toBe(true);
+        expect(TASK_ACTION_TYPES.has('tagMapReload')).toBe(true);
+    });
+    it('does not contain non-task types', () => {
+        expect(TASK_ACTION_TYPES.has('channelCreate')).toBe(false);
+    });
+});
+describe('executeTaskAction', () => {
+    it('taskCreate returns created task summary', async () => {
+        const result = await executeTaskAction({ type: 'taskCreate', title: 'New task', priority: 1 }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('ws-new');
+        expect(result.summary).toContain('New task');
+    });
+    it('taskCreate calls forumCountSync.requestUpdate', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        await executeTaskAction({ type: 'taskCreate', title: 'Counted task' }, makeCtx(), makeTaskCtx({ forumCountSync: mockSync }));
+        expect(mockSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('taskCreate fails without title', async () => {
+        const result = await executeTaskAction({ type: 'taskCreate', title: '' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(false);
+    });
+    it('taskCreate honors no-thread by skipping thread creation', async () => {
+        const { createTaskThread } = await import('./thread-ops.js');
+        createTaskThread.mockClear?.();
+        const result = await executeTaskAction({ type: 'taskCreate', title: 'No thread please', tags: 'no-thread,feature' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(true);
+        expect(createTaskThread).not.toHaveBeenCalled();
+    });
+    it('taskCreate skips thread creation when task is already linked before direct lifecycle step', async () => {
+        const { createTaskThread } = await import('./thread-ops.js');
+        createTaskThread.mockClear?.();
+        const store = makeStore();
+        store.get.mockImplementation((id) => ({
+            id,
+            title: 'Already linked',
+            status: 'open',
+            priority: 2,
+            issue_type: 'task',
+            owner: '',
+            external_ref: 'discord:thread-existing',
+            labels: ['feature'],
+            comments: [],
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-01T00:00:00Z',
+        }));
+        const result = await executeTaskAction({ type: 'taskCreate', title: 'Task already linked' }, makeCtx(), makeTaskCtx({ store: store }));
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('thread linked');
+        expect(createTaskThread).not.toHaveBeenCalled();
+    });
+    it('taskUpdate returns updated summary', async () => {
+        const result = await executeTaskAction({ type: 'taskUpdate', taskId: 'ws-001', status: 'in_progress', priority: 1 }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('ws-001');
+        expect(result.summary).toContain('in_progress');
+    });
+    it('taskUpdate calls forumCountSync.requestUpdate when status changed', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        await executeTaskAction({ type: 'taskUpdate', taskId: 'ws-001', status: 'in_progress' }, makeCtx(), makeTaskCtx({ forumCountSync: mockSync }));
+        expect(mockSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('taskUpdate does NOT call forumCountSync.requestUpdate without status change', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        await executeTaskAction({ type: 'taskUpdate', taskId: 'ws-001', title: 'New title' }, makeCtx(), makeTaskCtx({ forumCountSync: mockSync }));
+        expect(mockSync.requestUpdate).not.toHaveBeenCalled();
+    });
+    it('taskUpdate fails without taskId', async () => {
+        const result = await executeTaskAction({ type: 'taskUpdate', taskId: '' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(false);
+    });
+    it('taskUpdate calls updateTaskStarterMessage when task has a linked thread', async () => {
+        const { updateTaskStarterMessage } = await import('./thread-ops.js');
+        updateTaskStarterMessage.mockClear();
+        await executeTaskAction({ type: 'taskUpdate', taskId: 'ws-001', description: 'Updated desc' }, makeCtx(), makeTaskCtx());
+        expect(updateTaskStarterMessage).toHaveBeenCalledWith(expect.anything(), '111222333', expect.objectContaining({ id: 'ws-001' }), undefined);
+    });
+    it('taskUpdate passes sidebarMentionUserId to updateTaskStarterMessage', async () => {
+        const { updateTaskStarterMessage } = await import('./thread-ops.js');
+        updateTaskStarterMessage.mockClear();
+        await executeTaskAction({ type: 'taskUpdate', taskId: 'ws-001', description: 'Updated desc' }, makeCtx(), makeTaskCtx({ sidebarMentionUserId: '999' }));
+        expect(updateTaskStarterMessage).toHaveBeenCalledWith(expect.anything(), '111222333', expect.objectContaining({ id: 'ws-001' }), '999');
+    });
+    it('taskUpdate succeeds even if updateTaskStarterMessage throws', async () => {
+        const { updateTaskStarterMessage } = await import('./thread-ops.js');
+        updateTaskStarterMessage.mockRejectedValueOnce(new Error('Discord API error'));
+        const result = await executeTaskAction({ type: 'taskUpdate', taskId: 'ws-001', status: 'in_progress' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(true);
+    });
+    it('taskUpdate calls updateTaskThreadTags when task has a linked thread', async () => {
+        const { updateTaskThreadTags } = await import('./thread-ops.js');
+        updateTaskThreadTags.mockClear();
+        await executeTaskAction({ type: 'taskUpdate', taskId: 'ws-001', status: 'in_progress' }, makeCtx(), makeTaskCtx());
+        expect(updateTaskThreadTags).toHaveBeenCalledWith(expect.anything(), '111222333', expect.objectContaining({ id: 'ws-001' }), expect.objectContaining({ feature: 'tag-1' }));
+    });
+    it('taskClose passes tagMap to closeTaskThread', async () => {
+        const { closeTaskThread } = await import('./thread-ops.js');
+        closeTaskThread.mockClear();
+        const taskCtx = makeTaskCtx();
+        await executeTaskAction({ type: 'taskClose', taskId: 'ws-001', reason: 'Done' }, makeCtx(), taskCtx);
+        expect(closeTaskThread).toHaveBeenCalledWith(expect.anything(), '111222333', expect.objectContaining({ id: 'ws-001' }), taskCtx.tagMap, taskCtx.log);
+    });
+    it('taskUpdate rejects invalid status', async () => {
+        const result = await executeTaskAction({ type: 'taskUpdate', taskId: 'ws-001', status: 'nonsense' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Invalid');
+    });
+    it('taskClose returns closed summary', async () => {
+        const result = await executeTaskAction({ type: 'taskClose', taskId: 'ws-001', reason: 'Done' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('ws-001');
+        expect(result.summary).toContain('Done');
+    });
+    it('taskClose calls forumCountSync.requestUpdate', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        await executeTaskAction({ type: 'taskClose', taskId: 'ws-001' }, makeCtx(), makeTaskCtx({ forumCountSync: mockSync }));
+        expect(mockSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('taskShow returns task details', async () => {
+        const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-001' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('Test task');
+        expect(result.summary).toContain('ws-001');
+    });
+    it('taskShow fails for unknown task', async () => {
+        const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-notfound' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('not found');
+    });
+    it('taskList returns task list', async () => {
+        const result = await executeTaskAction({ type: 'taskList', status: 'open', limit: 10 }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('ws-001');
+        expect(result.summary).toContain('ws-002');
+    });
+    it('taskList defaults to limit 50 when no limit provided', async () => {
+        const store = makeStore();
+        await executeTaskAction({ type: 'taskList', status: 'all' }, makeCtx(), makeTaskCtx({ store: store }));
+        expect(store.list).toHaveBeenCalledWith(expect.objectContaining({ limit: 50 }));
+    });
+    it('taskList respects explicit limit', async () => {
+        const store = makeStore();
+        await executeTaskAction({ type: 'taskList', status: 'all', limit: 5 }, makeCtx(), makeTaskCtx({ store: store }));
+        expect(store.list).toHaveBeenCalledWith(expect.objectContaining({ limit: 5 }));
+    });
+    it('taskSync returns extended sync summary', async () => {
+        const result = await executeTaskAction({ type: 'taskSync' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('status-fixes');
+        expect(result.summary).toContain('5 starters');
+    });
+    it('taskSync passes statusPoster through to runTaskSync', async () => {
+        const { runTaskSync } = await import('./task-sync-engine.js');
+        runTaskSync.mockClear();
+        const mockPoster = { taskSyncComplete: vi.fn() };
+        await executeTaskAction({ type: 'taskSync' }, makeCtx(), makeTaskCtx({ statusPoster: mockPoster }));
+        expect(runTaskSync).toHaveBeenCalledWith(expect.objectContaining({ statusPoster: mockPoster, mentionUserId: undefined }));
+    });
+    it('taskSync passes sidebarMentionUserId as mentionUserId to runTaskSync', async () => {
+        const { runTaskSync } = await import('./task-sync-engine.js');
+        runTaskSync.mockClear();
+        await executeTaskAction({ type: 'taskSync' }, makeCtx(), makeTaskCtx({ sidebarMentionUserId: '999' }));
+        expect(runTaskSync).toHaveBeenCalledWith(expect.objectContaining({ mentionUserId: '999' }));
+    });
+    it('taskSync lazily creates and reuses syncCoordinator when missing', async () => {
+        const { runTaskSync } = await import('./task-sync-engine.js');
+        runTaskSync.mockClear();
+        const taskCtx = makeTaskCtx();
+        expect(taskCtx.syncCoordinator).toBeUndefined();
+        await executeTaskAction({ type: 'taskSync' }, makeCtx(), taskCtx);
+        const firstCoordinator = taskCtx.syncCoordinator;
+        expect(firstCoordinator).toBeDefined();
+        await executeTaskAction({ type: 'taskSync' }, makeCtx(), taskCtx);
+        expect(taskCtx.syncCoordinator).toBe(firstCoordinator);
+        expect(runTaskSync).toHaveBeenCalledTimes(2);
+    });
+    it('taskUpdate schedules repair sync after thread lifecycle failure without prewired coordinator', async () => {
+        const { runTaskSync } = await import('./task-sync-engine.js');
+        const { updateTaskThreadName } = await import('./thread-ops.js');
+        runTaskSync.mockClear();
+        updateTaskThreadName.mockRejectedValueOnce(new Error('rename failed'));
+        const result = await executeTaskAction({ type: 'taskUpdate', taskId: 'ws-001', status: 'in_progress' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(true);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(runTaskSync).toHaveBeenCalled();
+    });
+});
+describe('tagMapReload action', () => {
+    it('success: returns old/new count with tag names', async () => {
+        const { reloadTagMapInPlace } = await import('./tag-map.js');
+        reloadTagMapInPlace.mockClear();
+        reloadTagMapInPlace.mockImplementationOnce(async (_path, tagMap) => {
+            // Simulate reload: clear and add new tags
+            for (const k of Object.keys(tagMap))
+                delete tagMap[k];
+            Object.assign(tagMap, { bug: '111', feature: '222', docs: '333' });
+            return 3;
+        });
+        const result = await executeTaskAction({ type: 'tagMapReload' }, makeCtx(), makeTaskCtx({ tagMapPath: '/tmp/tag-map.json' }));
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('Tag map reloaded');
+        expect(result.summary).toContain('bug');
+        expect(result.summary).toContain('feature');
+        expect(result.summary).toContain('docs');
+    });
+    it('success with >10 tags: truncates tag list display', async () => {
+        const { reloadTagMapInPlace } = await import('./tag-map.js');
+        reloadTagMapInPlace.mockClear();
+        reloadTagMapInPlace.mockImplementationOnce(async (_path, tagMap) => {
+            for (const k of Object.keys(tagMap))
+                delete tagMap[k];
+            for (let i = 0; i < 15; i++)
+                tagMap[`tag${i}`] = `id${i}`;
+            return 15;
+        });
+        const result = await executeTaskAction({ type: 'tagMapReload' }, makeCtx(), makeTaskCtx({ tagMapPath: '/tmp/tag-map.json' }));
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('(+5 more)');
+    });
+    it('failure: returns error with message, map preserved', async () => {
+        const { reloadTagMapInPlace } = await import('./tag-map.js');
+        reloadTagMapInPlace.mockClear();
+        reloadTagMapInPlace.mockRejectedValueOnce(new Error('ENOENT: file not found'));
+        const tagMap = { existing: '999' };
+        const result = await executeTaskAction({ type: 'tagMapReload' }, makeCtx(), makeTaskCtx({ tagMapPath: '/tmp/tag-map.json', tagMap }));
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Tag map reload failed');
+        expect(result.error).toContain('ENOENT');
+    });
+    it('without tagMapPath: returns error', async () => {
+        const result = await executeTaskAction({ type: 'tagMapReload' }, makeCtx(), makeTaskCtx());
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Tag map path not configured');
+    });
+});
+describe('taskSync coordinator tagMap reload behavior', () => {
+    it('reloads tag map before runTaskSync when tagMapPath is configured', async () => {
+        const { reloadTagMapInPlace } = await import('./tag-map.js');
+        const { runTaskSync } = await import('./task-sync-engine.js');
+        reloadTagMapInPlace.mockClear();
+        runTaskSync.mockClear();
+        await executeTaskAction({ type: 'taskSync' }, makeCtx(), makeTaskCtx({ tagMapPath: '/tmp/tag-map.json' }));
+        expect(reloadTagMapInPlace).toHaveBeenCalledWith('/tmp/tag-map.json', expect.any(Object));
+        expect(runTaskSync).toHaveBeenCalled();
+    });
+    it('does not attempt reload without tagMapPath', async () => {
+        const { reloadTagMapInPlace } = await import('./tag-map.js');
+        reloadTagMapInPlace.mockClear();
+        await executeTaskAction({ type: 'taskSync' }, makeCtx(), makeTaskCtx());
+        expect(reloadTagMapInPlace).not.toHaveBeenCalled();
+    });
+});
+describe('taskActionsPromptSection', () => {
+    it('returns non-empty prompt section', () => {
+        const section = taskActionsPromptSection();
+        expect(section).toContain('taskCreate');
+        expect(section).toContain('taskClose');
+        expect(section).toContain('taskList');
+    });
+    it('includes tagMapReload in prompt section', () => {
+        const section = taskActionsPromptSection();
+        expect(section).toContain('tagMapReload');
+    });
+    it('includes task quality guidelines', () => {
+        const section = taskActionsPromptSection();
+        expect(section).toContain('imperative mood');
+        expect(section).toContain('Description');
+        expect(section).toContain('P0');
+        expect(section).toContain('P1');
+        expect(section).toContain('taskUpdate');
+    });
+    it('keeps guidelines block under 600 chars', () => {
+        const section = taskActionsPromptSection();
+        const marker = '#### Task Quality Guidelines';
+        const crossRefMarker = '#### Cross-Task References';
+        const idx = section.indexOf(marker);
+        expect(idx).toBeGreaterThanOrEqual(0);
+        const crossRefIdx = section.indexOf(crossRefMarker);
+        // Slice up to the cross-task section (or end of string if not found)
+        const end = crossRefIdx > idx ? crossRefIdx : section.length;
+        const guidelinesBlock = section.slice(idx, end);
+        expect(guidelinesBlock.length).toBeLessThanOrEqual(700);
+    });
+    it('includes cross-task references guideline', () => {
+        const section = taskActionsPromptSection();
+        expect(section).toContain('#### Cross-Task References');
+        expect(section).toContain('taskShow');
+        expect(section).toContain('taskUpdate');
+        expect(section).toContain('taskSync');
+    });
+});