discoclaw 0.1.0

package/dist/discord/shutdown-context.test.js

@@ -0,0 +1,279 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { writeShutdownContext, readAndClearShutdownContext, formatStartupInjection, } from './shutdown-context.js';
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'shutdown-ctx-test-'));
+});
+afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+});
+describe('writeShutdownContext', () => {
+    it('writes a valid JSON file', async () => {
+        const ctx = {
+            reason: 'restart-command',
+            message: 'User requested via !restart',
+            timestamp: '2026-02-13T00:00:00.000Z',
+            requestedBy: '12345',
+        };
+        await writeShutdownContext(tmpDir, ctx);
+        const raw = await fs.readFile(path.join(tmpDir, 'shutdown-context.json'), 'utf-8');
+        const parsed = JSON.parse(raw);
+        expect(parsed.reason).toBe('restart-command');
+        expect(parsed.requestedBy).toBe('12345');
+        expect(parsed.message).toBe('User requested via !restart');
+    });
+    it('does not leave tmp files on success', async () => {
+        await writeShutdownContext(tmpDir, {
+            reason: 'unknown',
+            timestamp: new Date().toISOString(),
+        });
+        const files = await fs.readdir(tmpDir);
+        expect(files).toEqual(['shutdown-context.json']);
+    });
+    it('overwrites existing file by default', async () => {
+        await writeShutdownContext(tmpDir, {
+            reason: 'restart-command',
+            timestamp: '2026-02-13T00:00:00.000Z',
+        });
+        await writeShutdownContext(tmpDir, {
+            reason: 'unknown',
+            timestamp: '2026-02-13T00:01:00.000Z',
+        });
+        const raw = await fs.readFile(path.join(tmpDir, 'shutdown-context.json'), 'utf-8');
+        expect(JSON.parse(raw).reason).toBe('unknown');
+    });
+    it('skips write when skipIfExists is true and file exists', async () => {
+        await writeShutdownContext(tmpDir, {
+            reason: 'restart-command',
+            message: 'rich context',
+            timestamp: '2026-02-13T00:00:00.000Z',
+        });
+        await writeShutdownContext(tmpDir, { reason: 'unknown', timestamp: '2026-02-13T00:01:00.000Z' }, { skipIfExists: true });
+        const raw = await fs.readFile(path.join(tmpDir, 'shutdown-context.json'), 'utf-8');
+        expect(JSON.parse(raw).reason).toBe('restart-command');
+        expect(JSON.parse(raw).message).toBe('rich context');
+    });
+    it('writes when skipIfExists is true but no file exists', async () => {
+        await writeShutdownContext(tmpDir, { reason: 'unknown', timestamp: '2026-02-13T00:00:00.000Z' }, { skipIfExists: true });
+        const raw = await fs.readFile(path.join(tmpDir, 'shutdown-context.json'), 'utf-8');
+        expect(JSON.parse(raw).reason).toBe('unknown');
+    });
+});
+describe('readAndClearShutdownContext', () => {
+    it('returns crash when no file exists', async () => {
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.type).toBe('crash');
+        expect(result.shutdown).toBeUndefined();
+    });
+    it('returns first-boot when no file exists and firstBoot hint is set', async () => {
+        const result = await readAndClearShutdownContext(tmpDir, { firstBoot: true });
+        expect(result.type).toBe('first-boot');
+        expect(result.shutdown).toBeUndefined();
+    });
+    it('ignores firstBoot hint when file exists', async () => {
+        await writeShutdownContext(tmpDir, {
+            reason: 'restart-command',
+            timestamp: '2026-02-13T00:00:00.000Z',
+        });
+        const result = await readAndClearShutdownContext(tmpDir, { firstBoot: true });
+        expect(result.type).toBe('intentional');
+    });
+    it('returns graceful-unknown for reason: unknown', async () => {
+        await writeShutdownContext(tmpDir, {
+            reason: 'unknown',
+            timestamp: '2026-02-13T00:00:00.000Z',
+        });
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.type).toBe('graceful-unknown');
+        expect(result.shutdown?.reason).toBe('unknown');
+    });
+    it('returns intentional for reason: restart-command', async () => {
+        await writeShutdownContext(tmpDir, {
+            reason: 'restart-command',
+            message: 'User requested',
+            timestamp: '2026-02-13T00:00:00.000Z',
+            requestedBy: '99999',
+        });
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.type).toBe('intentional');
+        expect(result.shutdown?.reason).toBe('restart-command');
+        expect(result.shutdown?.requestedBy).toBe('99999');
+    });
+    it('returns intentional for reason: deploy', async () => {
+        await writeShutdownContext(tmpDir, {
+            reason: 'deploy',
+            timestamp: '2026-02-13T00:00:00.000Z',
+        });
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.type).toBe('intentional');
+    });
+    it('deletes the file after reading', async () => {
+        await writeShutdownContext(tmpDir, {
+            reason: 'restart-command',
+            timestamp: '2026-02-13T00:00:00.000Z',
+        });
+        await readAndClearShutdownContext(tmpDir);
+        const files = await fs.readdir(tmpDir);
+        expect(files).toEqual([]);
+    });
+    it('returns crash for corrupted JSON', async () => {
+        await fs.writeFile(path.join(tmpDir, 'shutdown-context.json'), 'not json!!!', 'utf-8');
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.type).toBe('crash');
+    });
+    it.each([
+        ['null', 'null'],
+        ['string', '"hello"'],
+        ['number', '42'],
+        ['array', '[1,2,3]'],
+    ])('returns crash for valid JSON that is %s', async (_label, json) => {
+        await fs.writeFile(path.join(tmpDir, 'shutdown-context.json'), json, 'utf-8');
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.type).toBe('crash');
+    });
+    it('preserves activeForge in shutdown context', async () => {
+        await writeShutdownContext(tmpDir, {
+            reason: 'restart-command',
+            timestamp: '2026-02-13T00:00:00.000Z',
+            activeForge: 'plan-037',
+        });
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.shutdown?.activeForge).toBe('plan-037');
+    });
+    it('classifies unrecognized reason as graceful-unknown', async () => {
+        await fs.writeFile(path.join(tmpDir, 'shutdown-context.json'), JSON.stringify({ reason: 'banana', timestamp: '2026-02-13T00:00:00.000Z' }));
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.type).toBe('graceful-unknown');
+        expect(result.shutdown?.reason).toBe('unknown');
+    });
+    it('classifies missing reason as graceful-unknown', async () => {
+        await fs.writeFile(path.join(tmpDir, 'shutdown-context.json'), JSON.stringify({ timestamp: '2026-02-13T00:00:00.000Z' }));
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.type).toBe('graceful-unknown');
+    });
+    it('truncates oversized message and activeForge fields', async () => {
+        const long = 'x'.repeat(1000);
+        await fs.writeFile(path.join(tmpDir, 'shutdown-context.json'), JSON.stringify({ reason: 'restart-command', timestamp: '', message: long, activeForge: long }));
+        const result = await readAndClearShutdownContext(tmpDir);
+        expect(result.shutdown?.message?.length).toBe(500);
+        expect(result.shutdown?.activeForge?.length).toBe(500);
+    });
+});
+describe('formatStartupInjection', () => {
+    it('formats intentional restart', () => {
+        const ctx = {
+            type: 'intentional',
+            shutdown: {
+                reason: 'restart-command',
+                message: 'User requested via !restart',
+                timestamp: '2026-02-13T00:00:00.000Z',
+                requestedBy: '12345',
+            },
+        };
+        const result = formatStartupInjection(ctx);
+        expect(result).toContain('restarted via !restart');
+        expect(result).toContain('<@12345>');
+        expect(result).toContain('User requested via !restart');
+    });
+    it('formats intentional restart without requestedBy', () => {
+        const ctx = {
+            type: 'intentional',
+            shutdown: {
+                reason: 'restart-command',
+                timestamp: '2026-02-13T00:00:00.000Z',
+            },
+        };
+        const result = formatStartupInjection(ctx);
+        expect(result).toContain('restarted via !restart');
+        expect(result).not.toContain('<@');
+    });
+    it('formats deploy reason correctly', () => {
+        const ctx = {
+            type: 'intentional',
+            shutdown: {
+                reason: 'deploy',
+                timestamp: '2026-02-13T00:00:00.000Z',
+            },
+        };
+        const result = formatStartupInjection(ctx);
+        expect(result).toContain('restarted for a deploy');
+        expect(result).not.toContain('!restart');
+    });
+    it('formats code-fix reason correctly', () => {
+        const ctx = {
+            type: 'intentional',
+            shutdown: {
+                reason: 'code-fix',
+                message: 'Applied hotfix for memory leak',
+                timestamp: '2026-02-13T00:00:00.000Z',
+            },
+        };
+        const result = formatStartupInjection(ctx);
+        expect(result).toContain('apply a code fix');
+        expect(result).toContain('Applied hotfix for memory leak');
+        expect(result).not.toContain('!restart');
+    });
+    it('returns null for first-boot', () => {
+        const ctx = { type: 'first-boot' };
+        expect(formatStartupInjection(ctx)).toBeNull();
+    });
+    it('formats graceful-unknown', () => {
+        const ctx = {
+            type: 'graceful-unknown',
+            shutdown: {
+                reason: 'unknown',
+                timestamp: '2026-02-13T00:00:00.000Z',
+            },
+        };
+        const result = formatStartupInjection(ctx);
+        expect(result).toContain('graceful shutdown');
+        expect(result).toContain('reason unknown');
+    });
+    it('formats crash', () => {
+        const ctx = { type: 'crash' };
+        const result = formatStartupInjection(ctx);
+        expect(result).toContain('crashed or been killed');
+        expect(result).toContain('journalctl');
+    });
+    it('appends active forge info when present', () => {
+        const ctx = {
+            type: 'intentional',
+            shutdown: {
+                reason: 'restart-command',
+                timestamp: '2026-02-13T00:00:00.000Z',
+                activeForge: 'plan-037',
+            },
+        };
+        const result = formatStartupInjection(ctx);
+        expect(result).toContain('plan-037');
+        expect(result).toContain('forge run was in progress');
+    });
+    it('appends active forge info for crash type', () => {
+        // Crash with forge info shouldn't happen (no file = no forge info),
+        // but the formatter handles it gracefully.
+        const ctx = {
+            type: 'crash',
+            shutdown: {
+                reason: 'unknown',
+                timestamp: '2026-02-13T00:00:00.000Z',
+                activeForge: 'plan-042',
+            },
+        };
+        const result = formatStartupInjection(ctx);
+        expect(result).toContain('plan-042');
+    });
+    it('includes resolved-task guard for all non-null results', () => {
+        const cases = [
+            { type: 'intentional', shutdown: { reason: 'restart-command', timestamp: '' } },
+            { type: 'graceful-unknown', shutdown: { reason: 'unknown', timestamp: '' } },
+            { type: 'crash' },
+        ];
+        for (const ctx of cases) {
+            const result = formatStartupInjection(ctx);
+            expect(result).toContain('already resolved');
+        }
+    });
+});

package/dist/discord/startup-profile.test.js

@@ -0,0 +1,214 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { ActivityType, GatewayIntentBits } from 'discord.js';
+// We test the startup logic by calling startDiscordBot with mocked Client.
+// The module under test is src/discord.ts — we import startDiscordBot.
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+vi.mock('node:fs/promises', () => ({
+    default: {
+        readFile: vi.fn(async () => Buffer.from('fake-avatar')),
+        mkdir: vi.fn(async () => { }),
+        stat: vi.fn(async () => ({})),
+        writeFile: vi.fn(async () => { }),
+    },
+}));
+let mockClientInstance;
+vi.mock('discord.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        Client: vi.fn().mockImplementation(() => mockClientInstance),
+    };
+});
+// Suppress bootstrap side-effects.
+vi.mock('../discord/system-bootstrap.js', () => ({
+    selectBootstrapGuild: () => null,
+    ensureSystemScaffold: async () => null,
+}));
+import { startDiscordBot } from '../discord.js';
+import fs from 'node:fs/promises';
+function makeMockLog() {
+    return { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+}
+function makeMockClient(overrides = {}) {
+    const setPresence = vi.fn();
+    const setAvatar = vi.fn();
+    const setStatus = vi.fn();
+    const setActivity = vi.fn();
+    const user = { setPresence, setAvatar, setStatus, setActivity, id: 'bot-1' };
+    const guilds = new Map();
+    const guildObj = {
+        id: 'guild-1',
+        members: {
+            me: {
+                nickname: null,
+                user: { username: 'TestBot' },
+                setNickname: vi.fn(async () => { }),
+            },
+            fetchMe: vi.fn(async () => guildObj.members.me),
+        },
+    };
+    guilds.set('guild-1', guildObj);
+    return {
+        user,
+        guilds: { cache: { values: () => guilds.values(), get: (id) => guilds.get(id) } },
+        on: vi.fn().mockReturnThis(),
+        once: vi.fn((event, cb) => { if (event === 'ready')
+            cb(); }),
+        login: vi.fn(async () => { }),
+        isReady: vi.fn(() => true),
+        channels: { cache: { get: vi.fn() } },
+        ...overrides,
+    };
+}
+function baseParams(overrides = {}) {
+    return {
+        token: 'test-token',
+        allowUserIds: new Set(['123']),
+        botDisplayName: 'TestBot',
+        log: makeMockLog(),
+        requireChannelContext: false,
+        autoIndexChannelContext: false,
+        autoJoinThreads: false,
+        useRuntimeSessions: true,
+        runtime: { invoke: vi.fn() },
+        sessionManager: { getOrCreate: vi.fn(async () => 'sess') },
+        workspaceCwd: '/tmp/workspace',
+        projectCwd: '/tmp',
+        groupsDir: '/tmp/groups',
+        useGroupDirCwd: false,
+        runtimeModel: 'opus',
+        runtimeTools: [],
+        runtimeTimeoutMs: 1000,
+        discordActionsEnabled: false,
+        discordActionsChannels: false,
+        discordActionsMessaging: false,
+        discordActionsGuild: false,
+        discordActionsModeration: false,
+        discordActionsPolls: false,
+        discordActionsTasks: false,
+        discordActionsBotProfile: false,
+        messageHistoryBudget: 0,
+        summaryEnabled: false,
+        summaryModel: 'haiku',
+        summaryMaxChars: 2000,
+        summaryEveryNTurns: 5,
+        summaryDataDir: '/tmp/summaries',
+        summaryToDurableEnabled: false,
+        shortTermMemoryEnabled: false,
+        shortTermDataDir: '/tmp/shortterm',
+        shortTermMaxEntries: 20,
+        shortTermMaxAgeMs: 21600000,
+        shortTermInjectMaxChars: 1000,
+        durableMemoryEnabled: false,
+        durableDataDir: '/tmp/durable',
+        durableInjectMaxChars: 2000,
+        durableMaxItems: 200,
+        memoryCommandsEnabled: false,
+        actionFollowupDepth: 0,
+        reactionHandlerEnabled: false,
+        reactionRemoveHandlerEnabled: false,
+        reactionMaxAgeMs: 86400000,
+        streamStallWarningMs: 0,
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockClientInstance = makeMockClient();
+});
+// ---------------------------------------------------------------------------
+// Presence tests
+// ---------------------------------------------------------------------------
+describe('startup presence', () => {
+    it('setPresence called with correct payload when botStatus + botActivity set', async () => {
+        await startDiscordBot(baseParams({
+            botStatus: 'dnd',
+            botActivity: 'with beads',
+            botActivityType: 'Playing',
+        }));
+        expect(mockClientInstance.user.setPresence).toHaveBeenCalledWith({
+            status: 'dnd',
+            activities: [{ name: 'with beads', type: ActivityType.Playing }],
+        });
+    });
+    it('Custom activity uses state field', async () => {
+        await startDiscordBot(baseParams({
+            botActivity: 'Thinking hard',
+            botActivityType: 'Custom',
+        }));
+        expect(mockClientInstance.user.setPresence).toHaveBeenCalledWith({
+            activities: [{ name: 'Custom Status', type: ActivityType.Custom, state: 'Thinking hard' }],
+        });
+    });
+    it('status-only sets presence without activities key', async () => {
+        await startDiscordBot(baseParams({ botStatus: 'dnd' }));
+        expect(mockClientInstance.user.setPresence).toHaveBeenCalledWith({ status: 'dnd' });
+    });
+    it('activity-only sets presence without status key', async () => {
+        await startDiscordBot(baseParams({ botActivity: 'with beads', botActivityType: 'Playing' }));
+        expect(mockClientInstance.user.setPresence).toHaveBeenCalledWith({
+            activities: [{ name: 'with beads', type: ActivityType.Playing }],
+        });
+    });
+    it('setPresence not called when neither botStatus nor botActivity set', async () => {
+        await startDiscordBot(baseParams());
+        expect(mockClientInstance.user.setPresence).not.toHaveBeenCalled();
+    });
+    it('presence failure logged as warning, startup continues', async () => {
+        mockClientInstance.user.setPresence.mockImplementationOnce(() => { throw new Error('presence fail'); });
+        const log = makeMockLog();
+        const result = await startDiscordBot(baseParams({ botStatus: 'idle', log: log }));
+        expect(result.client).toBeDefined();
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ err: expect.any(Error) }), 'discord:presence failed to set');
+    });
+});
+// ---------------------------------------------------------------------------
+// Avatar tests
+// ---------------------------------------------------------------------------
+describe('startup avatar', () => {
+    it('setAvatar called with URL string for https sources', async () => {
+        await startDiscordBot(baseParams({ botAvatar: 'https://example.com/avatar.png' }));
+        expect(mockClientInstance.user.setAvatar).toHaveBeenCalledWith('https://example.com/avatar.png');
+    });
+    it('setAvatar called with URL string for http sources', async () => {
+        await startDiscordBot(baseParams({ botAvatar: 'http://example.com/avatar.png' }));
+        expect(mockClientInstance.user.setAvatar).toHaveBeenCalledWith('http://example.com/avatar.png');
+    });
+    it('setAvatar called with Buffer for file path sources', async () => {
+        await startDiscordBot(baseParams({ botAvatar: '/home/user/avatar.png' }));
+        expect(fs.readFile).toHaveBeenCalledWith('/home/user/avatar.png');
+        expect(mockClientInstance.user.setAvatar).toHaveBeenCalledWith(Buffer.from('fake-avatar'));
+    });
+    it('avatar failure logged as warning, startup continues', async () => {
+        mockClientInstance.user.setAvatar.mockRejectedValueOnce(new Error('rate limited'));
+        const log = makeMockLog();
+        const result = await startDiscordBot(baseParams({ botAvatar: 'https://example.com/avatar.png', log: log }));
+        expect(result.client).toBeDefined();
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ err: expect.any(Error), avatar: 'https://example.com/avatar.png' }), 'discord:avatar failed to set');
+    });
+});
+// ---------------------------------------------------------------------------
+// Reaction remove handler wiring tests
+// ---------------------------------------------------------------------------
+describe('reaction remove handler wiring', () => {
+    it('registers messageReactionRemove listener when reactionRemoveHandlerEnabled is true', async () => {
+        await startDiscordBot(baseParams({ reactionRemoveHandlerEnabled: true }));
+        const onCalls = mockClientInstance.on.mock.calls;
+        const events = onCalls.map((c) => c[0]);
+        expect(events).toContain('messageReactionRemove');
+    });
+    it('does NOT register messageReactionRemove listener when reactionRemoveHandlerEnabled is false', async () => {
+        await startDiscordBot(baseParams({ reactionRemoveHandlerEnabled: false }));
+        const onCalls = mockClientInstance.on.mock.calls;
+        const events = onCalls.map((c) => c[0]);
+        expect(events).not.toContain('messageReactionRemove');
+    });
+    it('enables GuildMessageReactions intent when only remove handler is enabled (add disabled)', async () => {
+        const { Client } = await import('discord.js');
+        await startDiscordBot(baseParams({ reactionHandlerEnabled: false, reactionRemoveHandlerEnabled: true }));
+        const constructorCall = Client.mock.calls.at(-1)[0];
+        expect(constructorCall.intents).toContain(GatewayIntentBits.GuildMessageReactions);
+    });
+});

package/dist/discord/status-channel.js

@@ -0,0 +1,190 @@
+import { NO_MENTIONS } from './allowed-mentions.js';
+/**
+ * Strip CLI args and prompt content from error messages so internals
+ * (SOUL.md, IDENTITY.md, full prompts) don't leak into status channel messages.
+ */
+export function sanitizeErrorMessage(raw) {
+    if (!raw)
+        return '(no message)';
+    // execa kill messages look like:
+    //   "Command was killed with SIGKILL (Forced termination): claude -p \"You are...\""
+    //   "Command was killed with SIGKILL (Forced termination): /usr/local/bin/claude ... -- \"You are...\""
+    // Match ": " followed by a path or bare name containing "claude" (the binary invocation).
+    const cliBinMatch = raw.match(/:\s+(?:\/\S*\/)?claude\s/);
+    if (cliBinMatch) {
+        return raw.slice(0, cliBinMatch.index).slice(0, 500);
+    }
+    // Positional prompt separator: " -- " followed by a quoted string (prompt content).
+    // execa formats args with single quotes in shortMessage, so check both quote styles.
+    const positionalMatch = raw.match(/ -- ["']/);
+    if (positionalMatch) {
+        return raw.slice(0, positionalMatch.index).slice(0, 500);
+    }
+    // Generic: if the message contains "claude -p" anywhere, truncate before it
+    const dashPIdx = raw.indexOf('claude -p');
+    if (dashPIdx !== -1) {
+        const prefix = raw.slice(0, dashPIdx).trimEnd();
+        return (prefix || 'Command failed').slice(0, 500);
+    }
+    // Safety-net truncation for any other long message
+    return raw.slice(0, 500);
+}
+/**
+ * Format a phase failure error for human-readable Discord display.
+ * Detects timeout patterns and emits "Phase **X** timed out after Y minutes".
+ * Non-timeout errors emit "Phase **X** failed: <sanitized error>".
+ * Output is always truncated to 500 chars.
+ */
+export function sanitizePhaseError(phaseId, raw, timeoutMs) {
+    // Detect execa/AbortSignal timeout patterns: "timed out after Nms"
+    const timeoutMatch = raw.match(/timed out after (\d+)ms/i);
+    if (timeoutMatch) {
+        const ms = timeoutMs ?? parseInt(timeoutMatch[1], 10);
+        const minutes = Math.round(ms / 60000);
+        const humanTime = ms >= 60000 ? `${minutes} minute${minutes !== 1 ? 's' : ''}` : `${Math.round(ms / 1000)} seconds`;
+        return `Phase **${phaseId}** timed out after ${humanTime}`.slice(0, 500);
+    }
+    return `Phase **${phaseId}** failed: ${sanitizeErrorMessage(raw)}`.slice(0, 500);
+}
+export function createStatusPoster(channel, opts) {
+    const name = opts?.botDisplayName ?? 'Discoclaw';
+    const log = opts?.log;
+    const send = async (content) => {
+        try {
+            await channel.send({ content, allowedMentions: NO_MENTIONS });
+        }
+        catch (err) {
+            log?.warn({ err }, 'status-channel: failed to post status message');
+        }
+    };
+    const sendTaskSyncComplete = async (result) => {
+        const { threadsCreated, emojisUpdated, starterMessagesUpdated, threadsArchived, statusesUpdated, tagsUpdated, threadsReconciled, orphanThreadsFound, warnings } = result;
+        const allZero = threadsCreated === 0 && emojisUpdated === 0 && starterMessagesUpdated === 0 && threadsArchived === 0 && statusesUpdated === 0 && tagsUpdated === 0 && (threadsReconciled ?? 0) === 0 && (orphanThreadsFound ?? 0) === 0;
+        if (allZero && warnings === 0)
+            return;
+        const parts = ['**Task Sync Complete**'];
+        if (threadsCreated > 0)
+            parts.push(`Created: ${threadsCreated}`);
+        if (emojisUpdated > 0)
+            parts.push(`Names Updated: ${emojisUpdated}`);
+        if (starterMessagesUpdated > 0)
+            parts.push(`Starters Updated: ${starterMessagesUpdated}`);
+        if (threadsArchived > 0)
+            parts.push(`Archived: ${threadsArchived}`);
+        if (statusesUpdated > 0)
+            parts.push(`Statuses Fixed: ${statusesUpdated}`);
+        if (tagsUpdated > 0)
+            parts.push(`Tags Updated: ${tagsUpdated}`);
+        if (threadsReconciled && threadsReconciled > 0)
+            parts.push(`Reconciled: ${threadsReconciled}`);
+        if (orphanThreadsFound && orphanThreadsFound > 0)
+            parts.push(`Orphans Found: ${orphanThreadsFound}`);
+        if (warnings > 0)
+            parts.push(`Warnings: ${warnings}`);
+        await send(parts.join(' · '));
+    };
+    return {
+        async online() {
+            await send(`**Bot Online** — ${name} is connected and ready.`);
+        },
+        async offline() {
+            await send(`**Bot Offline** — ${name} is shutting down.`);
+        },
+        async runtimeError(context, message) {
+            const ctx = [context.sessionKey, context.channelName].filter(Boolean).join(' · ');
+            await send(`**Runtime Error** [${ctx}]\n${sanitizeErrorMessage(message).slice(0, 500)}`);
+        },
+        async handlerError(context, err) {
+            await send(`**Handler Failure** [${context.sessionKey}]\n${sanitizeErrorMessage(String(err) || '(unknown error)').slice(0, 500)}`);
+        },
+        async actionFailed(actionType, error) {
+            await send(`**Action Failed** [${actionType || '(unknown)'}]\n${(error || '(unknown)').slice(0, 500)}`);
+        },
+        async taskSyncComplete(result) {
+            await sendTaskSyncComplete(result);
+        },
+        async bootReport(data) {
+            const typeLabel = {
+                crash: 'Crash',
+                intentional: 'Intentional',
+                'graceful-unknown': 'Graceful (unknown)',
+                'first-boot': 'First Boot',
+            };
+            const lines = ['**Boot Report**'];
+            lines.push(`Startup · ${typeLabel[data.startupType]}`);
+            if (data.bootDurationMs !== undefined)
+                lines.push(`Boot Time · ${data.bootDurationMs}ms`);
+            lines.push(`Model · ${data.runtimeModel || '(default)'}`);
+            if (data.permissionsStatus) {
+                const permLabel = data.permissionsStatus === 'ok'
+                    ? `ok (${data.permissionsTier ?? '?'})`
+                    : data.permissionsStatus === 'invalid'
+                        ? `INVALID${data.permissionsReason ? ` (${data.permissionsReason})` : ''}`
+                        : 'missing';
+                lines.push(`Permissions · ${permLabel}`);
+            }
+            else {
+                lines.push(`Permissions · ${data.permissionsTier || '(unset)'}`);
+            }
+            if (data.shutdownReason) {
+                const reasonParts = [data.shutdownReason];
+                if (data.shutdownRequestedBy)
+                    reasonParts.push(`by <@${data.shutdownRequestedBy}>`);
+                if (data.shutdownMessage)
+                    reasonParts.push(`— ${data.shutdownMessage}`);
+                lines.push(`Last Shutdown · ${reasonParts.join(' ')}`);
+            }
+            if (data.activeForge) {
+                lines.push(`Forge at Shutdown · ${data.activeForge.slice(0, 200)}`);
+            }
+            const tasksEnabled = data.tasksEnabled;
+            const tasksDbVersion = data.tasksDbVersion;
+            const tasksStatus = tasksEnabled
+                ? `on${tasksDbVersion ? ` · v${tasksDbVersion}` : ''}${data.forumResolved ? ' · forum ok' : ' · forum unresolved'}`
+                : 'off';
+            lines.push(`Tasks · ${tasksStatus}`);
+            const cronsStatus = data.cronsEnabled
+                ? `on${data.cronJobCount !== undefined ? ` · ${data.cronJobCount} job${data.cronJobCount !== 1 ? 's' : ''}` : ''}`
+                : 'off';
+            lines.push(`Crons · ${cronsStatus}`);
+            const memoryParts = [];
+            if (data.memoryEpisodicOn)
+                memoryParts.push('episodic');
+            if (data.memorySemanticOn)
+                memoryParts.push('semantic');
+            if (data.memoryWorkingOn)
+                memoryParts.push('working');
+            lines.push(`Memory · ${memoryParts.length > 0 ? memoryParts.join(', ') : 'off'}`);
+            lines.push(`Actions · ${data.actionCategoriesEnabled.length > 0 ? data.actionCategoriesEnabled.join(', ') : '(none)'}`);
+            lines.push(`Version · DiscoClaw ${data.buildVersion ?? '(unknown)'}`);
+            if (data.configWarnings && data.configWarnings > 0) {
+                lines.push(`Config Warnings · ${data.configWarnings}`);
+            }
+            if (data.credentialReport) {
+                lines.push(`Credentials · ${data.credentialReport}`);
+            }
+            if (data.credentialHealth && data.credentialHealth.length > 0) {
+                const passCount = data.credentialHealth.filter(c => c.status === 'pass').length;
+                const failCount = data.credentialHealth.filter(c => c.status === 'fail').length;
+                const skipCount = data.credentialHealth.filter(c => c.status === 'skip').length;
+                if (passCount === data.credentialHealth.length) {
+                    lines.push('Health · all pass');
+                }
+                else {
+                    const summary = [];
+                    if (passCount > 0)
+                        summary.push(`${passCount} pass`);
+                    if (failCount > 0)
+                        summary.push(`${failCount} fail`);
+                    if (skipCount > 0)
+                        summary.push(`${skipCount} skip`);
+                    lines.push(`Health · ${summary.join(', ')}`);
+                    for (const c of data.credentialHealth.filter(c => c.status === 'fail')) {
+                        lines.push(`  ${c.name}: ${c.detail ?? 'failed'}`);
+                    }
+                }
+            }
+            await send(lines.join('\n'));
+        },
+    };
+}