discoclaw 0.1.0

package/dist/discord/actions-beads.test.js

@@ -0,0 +1,372 @@
+import { describe, expect, it, vi } from 'vitest';
+import { BEAD_ACTION_TYPES, executeBeadAction, beadActionsPromptSection } from './actions-beads.js';
+// ---------------------------------------------------------------------------
+// Mocks — override discord-sync and related modules
+// ---------------------------------------------------------------------------
+vi.mock('../beads/discord-sync.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 () => { }),
+    getThreadIdFromTask: vi.fn((task) => {
+        const ref = task.externalRef ?? task.external_ref ?? '';
+        if (ref.startsWith('discord:'))
+            return ref.slice('discord:'.length);
+        return null;
+    }),
+    findExistingThreadForTask: vi.fn(async () => null),
+    reloadTagMapInPlace: vi.fn(async () => 2),
+}));
+vi.mock('../beads/auto-tag.js', () => ({
+    autoTagBead: vi.fn(async () => ['feature']),
+}));
+vi.mock('../beads/bead-sync.js', () => ({
+    runBeadSync: vi.fn(async () => ({
+        threadsCreated: 1,
+        emojisUpdated: 2,
+        starterMessagesUpdated: 5,
+        threadsArchived: 3,
+        statusesUpdated: 4,
+        tagsUpdated: 0,
+        warnings: 0,
+    })),
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeCtx() {
+    return {
+        guild: {},
+        client: {
+            channels: {
+                cache: {
+                    get: () => undefined,
+                },
+            },
+        },
+        channelId: 'test-channel',
+        messageId: 'test-message',
+    };
+}
+function makeStore() {
+    const defaultBead = (id) => ({
+        id,
+        title: 'Test bead',
+        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 defaultBead(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) => defaultBead(id)),
+        close: vi.fn((id) => ({ ...defaultBead(id), status: 'closed' })),
+        addLabel: vi.fn((id) => defaultBead(id)),
+    };
+}
+function makeBeadCtx(overrides) {
+    return {
+        beadsCwd: '/tmp/test-beads',
+        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('BEAD_ACTION_TYPES', () => {
+    it('contains all bead action types', () => {
+        expect(BEAD_ACTION_TYPES.has('beadCreate')).toBe(true);
+        expect(BEAD_ACTION_TYPES.has('beadUpdate')).toBe(true);
+        expect(BEAD_ACTION_TYPES.has('beadClose')).toBe(true);
+        expect(BEAD_ACTION_TYPES.has('beadShow')).toBe(true);
+        expect(BEAD_ACTION_TYPES.has('beadList')).toBe(true);
+        expect(BEAD_ACTION_TYPES.has('beadSync')).toBe(true);
+        expect(BEAD_ACTION_TYPES.has('tagMapReload')).toBe(true);
+    });
+    it('does not contain non-bead types', () => {
+        expect(BEAD_ACTION_TYPES.has('channelCreate')).toBe(false);
+    });
+});
+describe('executeBeadAction', () => {
+    it('beadCreate returns created bead summary', async () => {
+        const result = await executeBeadAction({ type: 'beadCreate', title: 'New task', priority: 1 }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('ws-new');
+        expect(result.summary).toContain('New task');
+    });
+    it('beadCreate calls forumCountSync.requestUpdate', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        await executeBeadAction({ type: 'beadCreate', title: 'Counted task' }, makeCtx(), makeBeadCtx({ forumCountSync: mockSync }));
+        expect(mockSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('beadCreate fails without title', async () => {
+        const result = await executeBeadAction({ type: 'beadCreate', title: '' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(false);
+    });
+    it('beadCreate honors no-thread by skipping thread creation', async () => {
+        const { createTaskThread } = await import('../beads/discord-sync.js');
+        createTaskThread.mockClear?.();
+        const result = await executeBeadAction({ type: 'beadCreate', title: 'No thread please', tags: 'no-thread,feature' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(true);
+        expect(createTaskThread).not.toHaveBeenCalled();
+    });
+    it('beadUpdate returns updated summary', async () => {
+        const result = await executeBeadAction({ type: 'beadUpdate', beadId: 'ws-001', status: 'in_progress', priority: 1 }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('ws-001');
+        expect(result.summary).toContain('in_progress');
+    });
+    it('beadUpdate calls forumCountSync.requestUpdate when status changed', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        await executeBeadAction({ type: 'beadUpdate', beadId: 'ws-001', status: 'in_progress' }, makeCtx(), makeBeadCtx({ forumCountSync: mockSync }));
+        expect(mockSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('beadUpdate does NOT call forumCountSync.requestUpdate without status change', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        await executeBeadAction({ type: 'beadUpdate', beadId: 'ws-001', title: 'New title' }, makeCtx(), makeBeadCtx({ forumCountSync: mockSync }));
+        expect(mockSync.requestUpdate).not.toHaveBeenCalled();
+    });
+    it('beadUpdate fails without beadId', async () => {
+        const result = await executeBeadAction({ type: 'beadUpdate', beadId: '' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(false);
+    });
+    it('beadUpdate calls updateBeadStarterMessage when bead has a linked thread', async () => {
+        const { updateTaskStarterMessage } = await import('../beads/discord-sync.js');
+        updateTaskStarterMessage.mockClear();
+        await executeBeadAction({ type: 'beadUpdate', beadId: 'ws-001', description: 'Updated desc' }, makeCtx(), makeBeadCtx());
+        expect(updateTaskStarterMessage).toHaveBeenCalledWith(expect.anything(), '111222333', expect.objectContaining({ id: 'ws-001' }), undefined);
+    });
+    it('beadUpdate passes sidebarMentionUserId to updateBeadStarterMessage', async () => {
+        const { updateTaskStarterMessage } = await import('../beads/discord-sync.js');
+        updateTaskStarterMessage.mockClear();
+        await executeBeadAction({ type: 'beadUpdate', beadId: 'ws-001', description: 'Updated desc' }, makeCtx(), makeBeadCtx({ sidebarMentionUserId: '999' }));
+        expect(updateTaskStarterMessage).toHaveBeenCalledWith(expect.anything(), '111222333', expect.objectContaining({ id: 'ws-001' }), '999');
+    });
+    it('beadUpdate succeeds even if updateBeadStarterMessage throws', async () => {
+        const { updateTaskStarterMessage } = await import('../beads/discord-sync.js');
+        updateTaskStarterMessage.mockRejectedValueOnce(new Error('Discord API error'));
+        const result = await executeBeadAction({ type: 'beadUpdate', beadId: 'ws-001', status: 'in_progress' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(true);
+    });
+    it('beadUpdate calls updateBeadThreadTags when bead has a linked thread', async () => {
+        const { updateTaskThreadTags } = await import('../beads/discord-sync.js');
+        updateTaskThreadTags.mockClear();
+        await executeBeadAction({ type: 'beadUpdate', beadId: 'ws-001', status: 'in_progress' }, makeCtx(), makeBeadCtx());
+        expect(updateTaskThreadTags).toHaveBeenCalledWith(expect.anything(), '111222333', expect.objectContaining({ id: 'ws-001' }), expect.objectContaining({ feature: 'tag-1' }));
+    });
+    it('beadClose passes tagMap to closeBeadThread', async () => {
+        const { closeTaskThread } = await import('../beads/discord-sync.js');
+        closeTaskThread.mockClear();
+        const beadCtx = makeBeadCtx();
+        await executeBeadAction({ type: 'beadClose', beadId: 'ws-001', reason: 'Done' }, makeCtx(), beadCtx);
+        expect(closeTaskThread).toHaveBeenCalledWith(expect.anything(), '111222333', expect.objectContaining({ id: 'ws-001' }), beadCtx.tagMap, beadCtx.log);
+    });
+    it('beadUpdate rejects invalid status', async () => {
+        const result = await executeBeadAction({ type: 'beadUpdate', beadId: 'ws-001', status: 'nonsense' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Invalid');
+    });
+    it('beadClose returns closed summary', async () => {
+        const result = await executeBeadAction({ type: 'beadClose', beadId: 'ws-001', reason: 'Done' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('ws-001');
+        expect(result.summary).toContain('Done');
+    });
+    it('beadClose calls forumCountSync.requestUpdate', async () => {
+        const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
+        await executeBeadAction({ type: 'beadClose', beadId: 'ws-001' }, makeCtx(), makeBeadCtx({ forumCountSync: mockSync }));
+        expect(mockSync.requestUpdate).toHaveBeenCalled();
+    });
+    it('beadShow returns bead details', async () => {
+        const result = await executeBeadAction({ type: 'beadShow', beadId: 'ws-001' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('Test bead');
+        expect(result.summary).toContain('ws-001');
+    });
+    it('beadShow fails for unknown bead', async () => {
+        const result = await executeBeadAction({ type: 'beadShow', beadId: 'ws-notfound' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('not found');
+    });
+    it('beadList returns bead list', async () => {
+        const result = await executeBeadAction({ type: 'beadList', status: 'open', limit: 10 }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('ws-001');
+        expect(result.summary).toContain('ws-002');
+    });
+    it('beadList defaults to limit 50 when no limit provided', async () => {
+        const store = makeStore();
+        await executeBeadAction({ type: 'beadList', status: 'all' }, makeCtx(), makeBeadCtx({ store: store }));
+        expect(store.list).toHaveBeenCalledWith(expect.objectContaining({ limit: 50 }));
+    });
+    it('beadList respects explicit limit', async () => {
+        const store = makeStore();
+        await executeBeadAction({ type: 'beadList', status: 'all', limit: 5 }, makeCtx(), makeBeadCtx({ store: store }));
+        expect(store.list).toHaveBeenCalledWith(expect.objectContaining({ limit: 5 }));
+    });
+    it('beadSync returns extended sync summary', async () => {
+        const result = await executeBeadAction({ type: 'beadSync' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('status-fixes');
+        expect(result.summary).toContain('5 starters');
+    });
+    it('beadSync passes statusPoster through to runBeadSync', async () => {
+        const { runBeadSync } = await import('../beads/bead-sync.js');
+        runBeadSync.mockClear();
+        const mockPoster = { beadSyncComplete: vi.fn() };
+        await executeBeadAction({ type: 'beadSync' }, makeCtx(), makeBeadCtx({ statusPoster: mockPoster }));
+        expect(runBeadSync).toHaveBeenCalledWith(expect.objectContaining({ statusPoster: mockPoster, mentionUserId: undefined }));
+    });
+    it('beadSync passes sidebarMentionUserId as mentionUserId to runBeadSync', async () => {
+        const { runBeadSync } = await import('../beads/bead-sync.js');
+        runBeadSync.mockClear();
+        await executeBeadAction({ type: 'beadSync' }, makeCtx(), makeBeadCtx({ sidebarMentionUserId: '999' }));
+        expect(runBeadSync).toHaveBeenCalledWith(expect.objectContaining({ mentionUserId: '999' }));
+    });
+});
+describe('tagMapReload action', () => {
+    it('success: returns old/new count with tag names', async () => {
+        const { reloadTagMapInPlace } = await import('../beads/discord-sync.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 executeBeadAction({ type: 'tagMapReload' }, makeCtx(), makeBeadCtx({ 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('../beads/discord-sync.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 executeBeadAction({ type: 'tagMapReload' }, makeCtx(), makeBeadCtx({ 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('../beads/discord-sync.js');
+        reloadTagMapInPlace.mockClear();
+        reloadTagMapInPlace.mockRejectedValueOnce(new Error('ENOENT: file not found'));
+        const tagMap = { existing: '999' };
+        const result = await executeBeadAction({ type: 'tagMapReload' }, makeCtx(), makeBeadCtx({ 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 executeBeadAction({ type: 'tagMapReload' }, makeCtx(), makeBeadCtx());
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Tag map path not configured');
+    });
+});
+describe('beadSync fallback with tagMapPath', () => {
+    it('reloads tag map before runBeadSync in fallback path', async () => {
+        const { reloadTagMapInPlace } = await import('../beads/discord-sync.js');
+        const { runBeadSync } = await import('../beads/bead-sync.js');
+        reloadTagMapInPlace.mockClear();
+        runBeadSync.mockClear();
+        await executeBeadAction({ type: 'beadSync' }, makeCtx(), makeBeadCtx({ tagMapPath: '/tmp/tag-map.json' }));
+        expect(reloadTagMapInPlace).toHaveBeenCalledWith('/tmp/tag-map.json', expect.any(Object));
+        expect(runBeadSync).toHaveBeenCalled();
+    });
+    it('does not attempt reload without tagMapPath', async () => {
+        const { reloadTagMapInPlace } = await import('../beads/discord-sync.js');
+        reloadTagMapInPlace.mockClear();
+        await executeBeadAction({ type: 'beadSync' }, makeCtx(), makeBeadCtx());
+        expect(reloadTagMapInPlace).not.toHaveBeenCalled();
+    });
+});
+describe('beadActionsPromptSection', () => {
+    it('returns non-empty prompt section', () => {
+        const section = beadActionsPromptSection();
+        expect(section).toContain('taskCreate');
+        expect(section).toContain('taskClose');
+        expect(section).toContain('taskList');
+    });
+    it('includes tagMapReload in prompt section', () => {
+        const section = beadActionsPromptSection();
+        expect(section).toContain('tagMapReload');
+    });
+    it('includes task quality guidelines', () => {
+        const section = beadActionsPromptSection();
+        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 = beadActionsPromptSection();
+        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(600);
+    });
+    it('includes cross-task references guideline', () => {
+        const section = beadActionsPromptSection();
+        expect(section).toContain('#### Cross-Task References');
+        expect(section).toContain('taskShow');
+        expect(section).toContain('taskUpdate');
+        expect(section).toContain('taskSync');
+        expect(section).toContain('Legacy aliases');
+    });
+});

package/dist/discord/actions-bot-profile.js

@@ -0,0 +1,107 @@
+import { ActivityType } from 'discord.js';
+const BOT_PROFILE_TYPE_MAP = {
+    botSetStatus: true,
+    botSetActivity: true,
+    botSetNickname: true,
+};
+export const BOT_PROFILE_ACTION_TYPES = new Set(Object.keys(BOT_PROFILE_TYPE_MAP));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const VALID_STATUSES = new Set(['online', 'idle', 'dnd', 'invisible']);
+export const ACTIVITY_TYPE_MAP = {
+    Playing: ActivityType.Playing,
+    Listening: ActivityType.Listening,
+    Watching: ActivityType.Watching,
+    Competing: ActivityType.Competing,
+    Custom: ActivityType.Custom,
+};
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+export async function executeBotProfileAction(action, ctx) {
+    const { client, guild } = ctx;
+    switch (action.type) {
+        case 'botSetStatus': {
+            if (!VALID_STATUSES.has(action.status)) {
+                return { ok: false, error: `Invalid status "${action.status}"; must be one of: online, idle, dnd, invisible` };
+            }
+            client.user.setStatus(action.status);
+            return { ok: true, summary: `Status set to ${action.status}` };
+        }
+        case 'botSetActivity': {
+            if (!action.name || typeof action.name !== 'string') {
+                return { ok: false, error: 'botSetActivity requires a non-empty "name" field' };
+            }
+            const typeName = action.activityType ?? 'Playing';
+            const typeNum = ACTIVITY_TYPE_MAP[typeName];
+            if (typeNum === undefined) {
+                return { ok: false, error: `Invalid activityType "${typeName}"; must be one of: Playing, Listening, Watching, Competing, Custom` };
+            }
+            if (typeName === 'Custom') {
+                client.user.setActivity({ name: 'Custom Status', type: ActivityType.Custom, state: action.name });
+            }
+            else {
+                client.user.setActivity({ name: action.name, type: typeNum });
+            }
+            return { ok: true, summary: `Activity set to ${typeName}: ${action.name}` };
+        }
+        case 'botSetNickname': {
+            if (!action.nickname || typeof action.nickname !== 'string') {
+                return { ok: false, error: 'botSetNickname requires a non-empty "nickname" field' };
+            }
+            let me = guild.members.me;
+            if (!me) {
+                try {
+                    me = await guild.members.fetchMe();
+                }
+                catch {
+                    return { ok: false, error: 'Could not fetch bot member in this guild' };
+                }
+            }
+            // Skip if nickname already matches (avoid unnecessary API call).
+            if (me.nickname === action.nickname) {
+                return { ok: true, summary: `Nickname already set to "${action.nickname}"` };
+            }
+            // Skip if no nickname is set and the username already matches.
+            if (me.nickname == null && me.user?.username === action.nickname) {
+                return { ok: true, summary: `Nickname already set to "${action.nickname}"` };
+            }
+            try {
+                await me.setNickname(action.nickname, 'Runtime nickname change via bot profile action');
+            }
+            catch (err) {
+                if (err?.code === 50013) {
+                    return { ok: false, error: 'Missing Permissions — cannot set nickname (check bot role permissions)' };
+                }
+                throw err;
+            }
+            return { ok: true, summary: `Nickname set to "${action.nickname}"` };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Prompt section
+// ---------------------------------------------------------------------------
+export function botProfileActionsPromptSection() {
+    return `### Bot Profile
+
+**botSetStatus** — Change the bot's online status:
+\`\`\`
+<discord-action>{"type":"botSetStatus","status":"idle"}</discord-action>
+\`\`\`
+- \`status\` (required): One of \`online\`, \`idle\`, \`dnd\`, \`invisible\`.
+
+**botSetActivity** — Set the bot's activity text:
+\`\`\`
+<discord-action>{"type":"botSetActivity","name":"with tasks","activityType":"Playing"}</discord-action>
+\`\`\`
+- \`name\` (required): The activity text shown in the bot's presence.
+- \`activityType\` (optional): One of \`Playing\` (default), \`Listening\`, \`Watching\`, \`Competing\`, \`Custom\`.
+
+**botSetNickname** — Change the bot's nickname in the current server:
+\`\`\`
+<discord-action>{"type":"botSetNickname","nickname":"Weston"}</discord-action>
+\`\`\`
+- \`nickname\` (required): The new display name for this server.`;
+}

package/dist/discord/actions-bot-profile.test.js

@@ -0,0 +1,138 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ActivityType } from 'discord.js';
+import { executeBotProfileAction } from './actions-bot-profile.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeCtx(overrides = {}) {
+    const setStatus = vi.fn();
+    const setActivity = vi.fn();
+    const setNickname = vi.fn();
+    const me = {
+        nickname: overrides.meNickname ?? null,
+        user: { username: 'TestBot' },
+        setNickname,
+    };
+    return {
+        client: {
+            user: { setStatus, setActivity },
+        },
+        guild: {
+            id: 'guild-1',
+            members: {
+                me: overrides.meNull ? null : me,
+                fetchMe: vi.fn(async () => me),
+            },
+        },
+        channelId: 'ch-1',
+        messageId: 'msg-1',
+    };
+}
+// ---------------------------------------------------------------------------
+// botSetStatus
+// ---------------------------------------------------------------------------
+describe('executeBotProfileAction — botSetStatus', () => {
+    it.each(['online', 'idle', 'dnd', 'invisible'])('sets status to %s', async (status) => {
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetStatus', status }, ctx);
+        expect(result).toEqual({ ok: true, summary: `Status set to ${status}` });
+        expect(ctx.client.user.setStatus).toHaveBeenCalledWith(status);
+    });
+    it('rejects invalid status', async () => {
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetStatus', status: 'away' }, ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Invalid status');
+    });
+});
+// ---------------------------------------------------------------------------
+// botSetActivity
+// ---------------------------------------------------------------------------
+describe('executeBotProfileAction — botSetActivity', () => {
+    it('defaults to Playing type', async () => {
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetActivity', name: 'with beads' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Activity set to Playing: with beads' });
+        expect(ctx.client.user.setActivity).toHaveBeenCalledWith({ name: 'with beads', type: ActivityType.Playing });
+    });
+    it('sets explicit Listening type', async () => {
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetActivity', name: 'music', activityType: 'Listening' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Activity set to Listening: music' });
+        expect(ctx.client.user.setActivity).toHaveBeenCalledWith({ name: 'music', type: ActivityType.Listening });
+    });
+    it('Custom type uses state field', async () => {
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetActivity', name: 'Thinking hard', activityType: 'Custom' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Activity set to Custom: Thinking hard' });
+        expect(ctx.client.user.setActivity).toHaveBeenCalledWith({
+            name: 'Custom Status',
+            type: ActivityType.Custom,
+            state: 'Thinking hard',
+        });
+    });
+    it('rejects invalid activityType', async () => {
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetActivity', name: 'test', activityType: 'Streaming' }, ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Invalid activityType');
+    });
+    it('rejects missing name', async () => {
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetActivity', name: '' }, ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('non-empty "name"');
+    });
+});
+// ---------------------------------------------------------------------------
+// botSetNickname
+// ---------------------------------------------------------------------------
+describe('executeBotProfileAction — botSetNickname', () => {
+    it('sets nickname in current guild', async () => {
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetNickname', nickname: 'Weston' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Nickname set to "Weston"' });
+        expect(ctx.guild.members.me.setNickname).toHaveBeenCalledWith('Weston', 'Runtime nickname change via bot profile action');
+    });
+    it('rejects missing nickname', async () => {
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetNickname', nickname: '' }, ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('non-empty "nickname"');
+    });
+    it('fetches me when members.me is null', async () => {
+        const ctx = makeCtx({ meNull: true });
+        const result = await executeBotProfileAction({ type: 'botSetNickname', nickname: 'Weston' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Nickname set to "Weston"' });
+        expect(ctx.guild.members.fetchMe).toHaveBeenCalled();
+    });
+    it('skips API call when nickname already matches', async () => {
+        const ctx = makeCtx({ meNickname: 'Weston' });
+        const result = await executeBotProfileAction({ type: 'botSetNickname', nickname: 'Weston' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Nickname already set to "Weston"' });
+        expect(ctx.guild.members.me.setNickname).not.toHaveBeenCalled();
+    });
+    it('skips API call when no nickname set and username matches', async () => {
+        // meNickname defaults to null; username is 'TestBot'
+        const ctx = makeCtx();
+        const result = await executeBotProfileAction({ type: 'botSetNickname', nickname: 'TestBot' }, ctx);
+        expect(result).toEqual({ ok: true, summary: 'Nickname already set to "TestBot"' });
+        expect(ctx.guild.members.me.setNickname).not.toHaveBeenCalled();
+    });
+    it('handles fetchMe failure gracefully', async () => {
+        const ctx = makeCtx({ meNull: true });
+        ctx.guild.members.fetchMe.mockRejectedValueOnce(new Error('fetch failed'));
+        const result = await executeBotProfileAction({ type: 'botSetNickname', nickname: 'Weston' }, ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Could not fetch bot member');
+    });
+    it('handles permission error (50013) gracefully', async () => {
+        const ctx = makeCtx();
+        const permErr = new Error('Missing Permissions');
+        permErr.code = 50013;
+        ctx.guild.members.me.setNickname.mockRejectedValueOnce(permErr);
+        const result = await executeBotProfileAction({ type: 'botSetNickname', nickname: 'Weston' }, ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Missing Permissions');
+    });
+});