discoclaw 0.1.0

package/dist/discord/forge-plan-registry.js

@@ -0,0 +1,68 @@
+// ---------------------------------------------------------------------------
+// Shared forge/plan lifecycle state
+// ---------------------------------------------------------------------------
+//
+// Centralizes the orchestrator reference, running plan IDs, and workspace
+// writer lock that were previously scattered across discord.ts module-level
+// variables. Both human `!` commands and action-initiated forge/plan/memory
+// operations coordinate through this registry.
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Workspace writer lock — serializes forge creates, plan phase runs, and
+// memory mutations that touch the workspace filesystem.
+// ---------------------------------------------------------------------------
+let writerLockChain = Promise.resolve();
+/**
+ * Acquire the workspace writer lock. Returns a release function.
+ * Callers must call `release()` when done, ideally in a finally block.
+ */
+export function acquireWriterLock() {
+    let release;
+    const prev = writerLockChain;
+    writerLockChain = new Promise((resolve) => { release = resolve; });
+    return prev.then(() => release);
+}
+// ---------------------------------------------------------------------------
+// Active forge orchestrator
+// ---------------------------------------------------------------------------
+let _activeOrchestrator = null;
+/** Set the active forge orchestrator (or null to clear). */
+export function setActiveOrchestrator(orch) {
+    _activeOrchestrator = orch;
+}
+/** Get the active forge orchestrator, if any. */
+export function getActiveOrchestrator() {
+    return _activeOrchestrator;
+}
+/** Returns the active forge plan ID if a forge is running, undefined otherwise. */
+export function getActiveForgeId() {
+    return _activeOrchestrator?.activePlanId;
+}
+// ---------------------------------------------------------------------------
+// Running plan IDs — tracks which plans have active phase runs.
+// ---------------------------------------------------------------------------
+const _runningPlanIds = new Set();
+/** Mark a plan as having an active phase run. */
+export function addRunningPlan(planId) {
+    _runningPlanIds.add(planId);
+}
+/** Remove a plan from the active runs set. */
+export function removeRunningPlan(planId) {
+    _runningPlanIds.delete(planId);
+}
+/** Check if a plan has an active phase run. */
+export function isPlanRunning(planId) {
+    return _runningPlanIds.has(planId);
+}
+/** Get all currently running plan IDs (snapshot). */
+export function getRunningPlanIds() {
+    return _runningPlanIds;
+}
+// ---------------------------------------------------------------------------
+// Test helper — reset all state (for test isolation)
+// ---------------------------------------------------------------------------
+export function _resetForTest() {
+    writerLockChain = Promise.resolve();
+    _activeOrchestrator = null;
+    _runningPlanIds.clear();
+}

package/dist/discord/forge-plan-registry.test.js

@@ -0,0 +1,127 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { acquireWriterLock, setActiveOrchestrator, getActiveOrchestrator, getActiveForgeId, addRunningPlan, removeRunningPlan, isPlanRunning, getRunningPlanIds, _resetForTest, } from './forge-plan-registry.js';
+beforeEach(() => {
+    _resetForTest();
+});
+// ---------------------------------------------------------------------------
+// Writer lock
+// ---------------------------------------------------------------------------
+describe('acquireWriterLock', () => {
+    it('serializes concurrent acquires', async () => {
+        const order = [];
+        const r1 = await acquireWriterLock();
+        const p2 = acquireWriterLock().then((r2) => {
+            order.push(2);
+            r2();
+        });
+        // r1 is held, so p2 should not have resolved yet
+        await Promise.resolve(); // flush microtasks
+        expect(order).toEqual([]);
+        order.push(1);
+        r1(); // release first lock
+        await p2;
+        expect(order).toEqual([1, 2]);
+    });
+    it('works for sequential acquire-release cycles', async () => {
+        const r1 = await acquireWriterLock();
+        r1();
+        const r2 = await acquireWriterLock();
+        r2();
+        // No deadlock — if we got here, it works
+        expect(true).toBe(true);
+    });
+    it('chains three acquires in order', async () => {
+        const order = [];
+        const r1 = await acquireWriterLock();
+        const p2 = acquireWriterLock().then((r) => { order.push(2); r(); });
+        const p3 = acquireWriterLock().then((r) => { order.push(3); r(); });
+        order.push(1);
+        r1();
+        await Promise.all([p2, p3]);
+        expect(order).toEqual([1, 2, 3]);
+    });
+});
+// ---------------------------------------------------------------------------
+// Active forge orchestrator
+// ---------------------------------------------------------------------------
+describe('active orchestrator', () => {
+    it('starts as null', () => {
+        expect(getActiveOrchestrator()).toBeNull();
+        expect(getActiveForgeId()).toBeUndefined();
+    });
+    it('set and get', () => {
+        const fake = { activePlanId: 'plan-001' };
+        setActiveOrchestrator(fake);
+        expect(getActiveOrchestrator()).toBe(fake);
+        expect(getActiveForgeId()).toBe('plan-001');
+    });
+    it('clear', () => {
+        const fake = { activePlanId: 'plan-001' };
+        setActiveOrchestrator(fake);
+        setActiveOrchestrator(null);
+        expect(getActiveOrchestrator()).toBeNull();
+        expect(getActiveForgeId()).toBeUndefined();
+    });
+    it('returns undefined when orchestrator has no activePlanId', () => {
+        const fake = { activePlanId: undefined };
+        setActiveOrchestrator(fake);
+        expect(getActiveForgeId()).toBeUndefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// Running plan IDs
+// ---------------------------------------------------------------------------
+describe('running plan IDs', () => {
+    it('starts empty', () => {
+        expect(isPlanRunning('plan-001')).toBe(false);
+        expect(getRunningPlanIds().size).toBe(0);
+    });
+    it('add and check', () => {
+        addRunningPlan('plan-001');
+        expect(isPlanRunning('plan-001')).toBe(true);
+        expect(isPlanRunning('plan-002')).toBe(false);
+        expect(getRunningPlanIds().size).toBe(1);
+    });
+    it('remove', () => {
+        addRunningPlan('plan-001');
+        removeRunningPlan('plan-001');
+        expect(isPlanRunning('plan-001')).toBe(false);
+        expect(getRunningPlanIds().size).toBe(0);
+    });
+    it('remove non-existent is a no-op', () => {
+        removeRunningPlan('plan-999');
+        expect(getRunningPlanIds().size).toBe(0);
+    });
+    it('tracks multiple plans', () => {
+        addRunningPlan('plan-001');
+        addRunningPlan('plan-002');
+        expect(isPlanRunning('plan-001')).toBe(true);
+        expect(isPlanRunning('plan-002')).toBe(true);
+        expect(getRunningPlanIds().size).toBe(2);
+        removeRunningPlan('plan-001');
+        expect(isPlanRunning('plan-001')).toBe(false);
+        expect(isPlanRunning('plan-002')).toBe(true);
+    });
+    it('duplicate add is idempotent', () => {
+        addRunningPlan('plan-001');
+        addRunningPlan('plan-001');
+        expect(getRunningPlanIds().size).toBe(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// Reset
+// ---------------------------------------------------------------------------
+describe('_resetForTest', () => {
+    it('clears all state', async () => {
+        setActiveOrchestrator({ activePlanId: 'plan-001' });
+        addRunningPlan('plan-002');
+        // Acquire a lock and don't release — reset should clear the chain
+        await acquireWriterLock();
+        _resetForTest();
+        expect(getActiveOrchestrator()).toBeNull();
+        expect(isPlanRunning('plan-002')).toBe(false);
+        // Lock should be acquirable after reset (not stuck behind unreleased previous lock)
+        const r = await acquireWriterLock();
+        r();
+    });
+});

package/dist/discord/forum-count-sync.js

@@ -0,0 +1,130 @@
+import { ChannelType } from 'discord.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Strip a trailing `・N` (or legacy ` ・ N`, `(N)`, `-・-N`) count suffix from a forum name. */
+export function stripCountSuffix(name) {
+    let result = name;
+    // Loop to handle stacked corruption (e.g. "tasks-6-・-・-6" from multiple
+    // rounds of count-sync running on already-slugified names).
+    let prev;
+    do {
+        prev = result;
+        // Strip structured suffix: `・N`, ` ・ N`, `-・-N`, or `(N)`.
+        result = result.replace(/[\s-]*(?:・[\s-]*\d+|\(\d+\))$/, '');
+        // Clean up any trailing separator debris (lone `・` without a count digit).
+        result = result.replace(/[\s-]*・[\s-]*$/, '');
+        // Strip Discord-slugified numeric suffix (e.g. "tasks-6" from "tasks (6)").
+        // Greedy: a forum named "tasks-3" loses the "-3". Acceptable since
+        // count sync is the only thing that sets these suffixed names.
+        result = result.replace(/-\d+$/, '');
+    } while (result !== prev);
+    return result;
+}
+// ---------------------------------------------------------------------------
+// ForumCountSync
+// ---------------------------------------------------------------------------
+const DEBOUNCE_MS = 10_000; // 10s debounce after last requestUpdate()
+const MIN_INTERVAL_MS = 5 * 60_000; // 5min minimum between actual setName() calls
+/**
+ * Keeps a forum channel name in sync with a dynamic item count.
+ * Aggressively debounces to stay within Discord's 2-per-10-min channel rename limit.
+ */
+export class ForumCountSync {
+    client;
+    forumId;
+    countFn;
+    log;
+    debounceTimer = null;
+    deferredTimer = null;
+    lastUpdateMs = 0;
+    stopped = false;
+    constructor(client, forumId, countFn, log) {
+        this.client = client;
+        this.forumId = forumId;
+        this.countFn = countFn;
+        this.log = log;
+    }
+    /** Schedule a count update (debounced). */
+    requestUpdate() {
+        if (this.stopped)
+            return;
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            void this.execute();
+        }, DEBOUNCE_MS);
+    }
+    /** Cancel all pending timers. */
+    stop() {
+        this.stopped = true;
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.deferredTimer) {
+            clearTimeout(this.deferredTimer);
+            this.deferredTimer = null;
+        }
+    }
+    async execute() {
+        if (this.stopped)
+            return;
+        // Rate-limit: if last setName() was too recent, defer.
+        const now = Date.now();
+        const elapsed = now - this.lastUpdateMs;
+        if (elapsed < MIN_INTERVAL_MS && this.lastUpdateMs > 0) {
+            const remaining = MIN_INTERVAL_MS - elapsed;
+            this.log?.info({ forumId: this.forumId, deferMs: remaining }, 'forum-count-sync: deferred (rate limit)');
+            if (this.deferredTimer)
+                clearTimeout(this.deferredTimer);
+            this.deferredTimer = setTimeout(() => {
+                this.deferredTimer = null;
+                void this.execute();
+            }, remaining);
+            return;
+        }
+        let count;
+        try {
+            count = await this.countFn();
+        }
+        catch (err) {
+            this.log?.warn({ err, forumId: this.forumId }, 'forum-count-sync: countFn failed');
+            return;
+        }
+        const channel = this.client.channels.cache.get(this.forumId);
+        if (!channel || channel.type !== ChannelType.GuildForum) {
+            this.log?.warn({ forumId: this.forumId }, 'forum-count-sync: forum channel not found or not a forum');
+            return;
+        }
+        const currentName = channel.name;
+        const baseName = stripCountSuffix(currentName);
+        const newName = `${baseName}・${count}`;
+        if (newName === currentName) {
+            this.log?.info({ forumId: this.forumId, name: currentName }, 'forum-count-sync: name unchanged, skipping');
+            return;
+        }
+        try {
+            await channel.setName(newName);
+            this.lastUpdateMs = Date.now();
+            this.log?.info({ forumId: this.forumId, name: newName }, 'forum-count-sync: updated');
+        }
+        catch (err) {
+            // Handle Discord 429 rate limit.
+            const retryAfter = err?.retryAfter ?? err?.retry_after;
+            if (retryAfter && typeof retryAfter === 'number') {
+                const retryMs = retryAfter * 1000;
+                this.log?.warn({ forumId: this.forumId, retryAfter }, 'forum-count-sync: rate limited, rescheduling');
+                if (this.deferredTimer)
+                    clearTimeout(this.deferredTimer);
+                this.deferredTimer = setTimeout(() => {
+                    this.deferredTimer = null;
+                    void this.execute();
+                }, retryMs);
+                return;
+            }
+            this.log?.warn({ err, forumId: this.forumId }, 'forum-count-sync: setName failed');
+        }
+    }
+}

package/dist/discord/forum-count-sync.test.js

@@ -0,0 +1,200 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { ForumCountSync, stripCountSuffix } from './forum-count-sync.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function mockChannel(name) {
+    return {
+        name,
+        type: 15, // ChannelType.GuildForum
+        setName: vi.fn(async () => { }),
+    };
+}
+function makeClient(channel) {
+    return {
+        channels: {
+            cache: {
+                get: vi.fn(() => channel),
+            },
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// stripCountSuffix
+// ---------------------------------------------------------------------------
+describe('stripCountSuffix', () => {
+    it('strips count suffix from "beads ・ 12"', () => {
+        expect(stripCountSuffix('beads ・ 12')).toBe('beads');
+    });
+    it('no-ops on name without suffix', () => {
+        expect(stripCountSuffix('automations')).toBe('automations');
+    });
+    it('strips count suffix from "my forum ・ 0"', () => {
+        expect(stripCountSuffix('my forum ・ 0')).toBe('my forum');
+    });
+    it('handles multiple spaces around separator', () => {
+        expect(stripCountSuffix('beads  ・  5')).toBe('beads');
+    });
+    it('strips Discord-slugified suffix "beads-6"', () => {
+        expect(stripCountSuffix('beads-6')).toBe('beads');
+    });
+    it('strips slugified suffix from multi-dash name "my-cool-forum-12"', () => {
+        expect(stripCountSuffix('my-cool-forum-12')).toBe('my-cool-forum');
+    });
+    it('strips mixed corruption "beads-6 ・ 5" back to base name', () => {
+        expect(stripCountSuffix('beads-6 ・ 5')).toBe('beads');
+    });
+    it('strips Discord-slugified separator "automations-・-1"', () => {
+        expect(stripCountSuffix('automations-・-1')).toBe('automations');
+    });
+    it('strips stacked slugified corruption "beads-6-・-・-6"', () => {
+        expect(stripCountSuffix('beads-6-・-・-6')).toBe('beads');
+    });
+    it('strips compact format "automations・1"', () => {
+        expect(stripCountSuffix('automations・1')).toBe('automations');
+    });
+});
+// ---------------------------------------------------------------------------
+// ForumCountSync
+// ---------------------------------------------------------------------------
+describe('ForumCountSync', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('debounces multiple rapid requestUpdate() calls into single setName()', async () => {
+        const channel = mockChannel('beads');
+        const client = makeClient(channel);
+        const countFn = vi.fn(() => 5);
+        const sync = new ForumCountSync(client, 'forum-1', countFn);
+        sync.requestUpdate();
+        sync.requestUpdate();
+        sync.requestUpdate();
+        // Advance past debounce (10s).
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(countFn).toHaveBeenCalledTimes(1);
+        expect(channel.setName).toHaveBeenCalledTimes(1);
+        expect(channel.setName).toHaveBeenCalledWith('beads・5');
+        sync.stop();
+    });
+    it('rate-limits: second call within 5min defers to remaining time', async () => {
+        const channel = mockChannel('beads');
+        const client = makeClient(channel);
+        let count = 3;
+        const countFn = vi.fn(() => count);
+        const sync = new ForumCountSync(client, 'forum-1', countFn);
+        // First update.
+        sync.requestUpdate();
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(channel.setName).toHaveBeenCalledTimes(1);
+        expect(channel.setName).toHaveBeenCalledWith('beads・3');
+        // Second update shortly after.
+        count = 4;
+        // Update the channel mock name to reflect last setName.
+        channel.name = 'beads・3';
+        sync.requestUpdate();
+        await vi.advanceTimersByTimeAsync(10_000); // debounce fires, but rate limit defers
+        // Should not have made a second setName yet (rate-limited).
+        expect(channel.setName).toHaveBeenCalledTimes(1);
+        // Advance to remaining time (~5min - 20s = ~280s).
+        await vi.advanceTimersByTimeAsync(5 * 60_000);
+        expect(channel.setName).toHaveBeenCalledTimes(2);
+        expect(channel.setName).toHaveBeenLastCalledWith('beads・4');
+        sync.stop();
+    });
+    it('no-op does not consume rate budget', async () => {
+        const channel = mockChannel('beads・5');
+        const client = makeClient(channel);
+        const countFn = vi.fn(() => 5);
+        const sync = new ForumCountSync(client, 'forum-1', countFn);
+        // First update: name unchanged, no setName call.
+        sync.requestUpdate();
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(countFn).toHaveBeenCalledTimes(1);
+        expect(channel.setName).not.toHaveBeenCalled();
+        // Second update shortly after with different count — should execute immediately
+        // (no rate limit since lastUpdateMs was never set).
+        countFn.mockReturnValue(6);
+        sync.requestUpdate();
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(channel.setName).toHaveBeenCalledTimes(1);
+        expect(channel.setName).toHaveBeenCalledWith('beads・6');
+        sync.stop();
+    });
+    it('deferred timer fires and executes the update', async () => {
+        const channel = mockChannel('beads');
+        const client = makeClient(channel);
+        let count = 1;
+        const countFn = vi.fn(() => count);
+        const log = { info: vi.fn(), warn: vi.fn() };
+        const sync = new ForumCountSync(client, 'forum-1', countFn, log);
+        // First update to set lastUpdateMs.
+        sync.requestUpdate();
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(channel.setName).toHaveBeenCalledTimes(1);
+        // Request another update (will be deferred).
+        count = 2;
+        channel.name = 'beads・1';
+        sync.requestUpdate();
+        await vi.advanceTimersByTimeAsync(10_000); // debounce fires
+        // Should have logged deferred.
+        expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ forumId: 'forum-1' }), expect.stringContaining('deferred'));
+        // Advance past the remaining rate limit time.
+        await vi.advanceTimersByTimeAsync(5 * 60_000);
+        expect(channel.setName).toHaveBeenCalledTimes(2);
+        sync.stop();
+    });
+    it('countFn error is logged and does not throw or call setName', async () => {
+        const channel = mockChannel('beads');
+        const client = makeClient(channel);
+        const countFn = vi.fn(() => { throw new Error('count failed'); });
+        const log = { info: vi.fn(), warn: vi.fn() };
+        const sync = new ForumCountSync(client, 'forum-1', countFn, log);
+        sync.requestUpdate();
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ forumId: 'forum-1' }), expect.stringContaining('countFn failed'));
+        expect(channel.setName).not.toHaveBeenCalled();
+        sync.stop();
+    });
+    it('429 error reschedules at retry_after duration', async () => {
+        const channel = mockChannel('beads');
+        const rateLimitError = Object.assign(new Error('rate limited'), { retryAfter: 30 });
+        channel.setName = vi.fn(async () => { throw rateLimitError; });
+        const client = makeClient(channel);
+        const countFn = vi.fn(() => 5);
+        const log = { info: vi.fn(), warn: vi.fn() };
+        const sync = new ForumCountSync(client, 'forum-1', countFn, log);
+        sync.requestUpdate();
+        await vi.advanceTimersByTimeAsync(10_000); // debounce fires, setName throws 429
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ forumId: 'forum-1', retryAfter: 30 }), expect.stringContaining('rate limited'));
+        // Fix setName for retry.
+        channel.setName = vi.fn(async () => { });
+        await vi.advanceTimersByTimeAsync(30_000); // retry_after fires
+        expect(channel.setName).toHaveBeenCalledWith('beads・5');
+        sync.stop();
+    });
+    it('recovers base name from slugified channel name "beads-6"', async () => {
+        const channel = mockChannel('beads-6');
+        const client = makeClient(channel);
+        const countFn = vi.fn(() => 5);
+        const sync = new ForumCountSync(client, 'forum-1', countFn);
+        sync.requestUpdate();
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(channel.setName).toHaveBeenCalledTimes(1);
+        expect(channel.setName).toHaveBeenCalledWith('beads・5');
+        sync.stop();
+    });
+    it('stop() cancels all pending timers', async () => {
+        const channel = mockChannel('beads');
+        const client = makeClient(channel);
+        const countFn = vi.fn(() => 5);
+        const sync = new ForumCountSync(client, 'forum-1', countFn);
+        sync.requestUpdate();
+        sync.stop();
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(countFn).not.toHaveBeenCalled();
+        expect(channel.setName).not.toHaveBeenCalled();
+    });
+});

package/dist/discord/health-command.js

@@ -0,0 +1,98 @@
+import { renderMemoryLine } from '../observability/memory-sampler.js';
+export function parseHealthCommand(content) {
+    const normalized = String(content ?? '').trim().toLowerCase().replace(/\s+/g, ' ');
+    if (normalized === '!health')
+        return 'basic';
+    if (normalized === '!health verbose')
+        return 'verbose';
+    if (normalized === '!health tools')
+        return 'tools';
+    return null;
+}
+function formatUptime(ms) {
+    const seconds = Math.max(0, Math.floor(ms / 1000));
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = seconds % 60;
+    return `${h}h ${m}m ${s}s`;
+}
+function asCount(counters, name) {
+    return Number(counters[name] ?? 0);
+}
+function formatTaskSyncVerboseLines(counters) {
+    const started = asCount(counters, 'tasks.sync.started');
+    const succeeded = asCount(counters, 'tasks.sync.succeeded');
+    const failed = asCount(counters, 'tasks.sync.failed');
+    const coalesced = asCount(counters, 'tasks.sync.coalesced');
+    const durationTotalMs = asCount(counters, 'tasks.sync.duration_ms.total');
+    const durationSamples = asCount(counters, 'tasks.sync.duration_ms.samples');
+    const avgMs = durationSamples > 0
+        ? Math.round((durationTotalMs / durationSamples) * 100) / 100
+        : 0;
+    if (started === 0 && coalesced === 0) {
+        return ['Task sync: no runs yet'];
+    }
+    const lines = [];
+    lines.push(`Task sync: started=${started} ok=${succeeded} failed=${failed} coalesced=${coalesced} avgMs=${avgMs}`);
+    lines.push(`Task sync transitions: created=${asCount(counters, 'tasks.sync.transition.threads_created')} renamed=${asCount(counters, 'tasks.sync.transition.thread_names_updated')} starter=${asCount(counters, 'tasks.sync.transition.starter_messages_updated')} statuses=${asCount(counters, 'tasks.sync.transition.statuses_updated')} tags=${asCount(counters, 'tasks.sync.transition.tags_updated')} archived=${asCount(counters, 'tasks.sync.transition.threads_archived')} reconciled=${asCount(counters, 'tasks.sync.transition.threads_reconciled')} orphans=${asCount(counters, 'tasks.sync.transition.orphan_threads_found')} deferred=${asCount(counters, 'tasks.sync.transition.closes_deferred')} warnings=${asCount(counters, 'tasks.sync.transition.warnings')}`);
+    lines.push(`Task sync follow-up/retry: followUp=${asCount(counters, 'tasks.sync.follow_up.scheduled')}/${asCount(counters, 'tasks.sync.follow_up.triggered')}/${asCount(counters, 'tasks.sync.follow_up.succeeded')}/${asCount(counters, 'tasks.sync.follow_up.failed')} retry=${asCount(counters, 'tasks.sync.retry.scheduled')}/${asCount(counters, 'tasks.sync.retry.triggered')}/${asCount(counters, 'tasks.sync.retry.failed')} (coalesced=${asCount(counters, 'tasks.sync.retry.coalesced')} canceled=${asCount(counters, 'tasks.sync.retry.canceled')}) failureRetry=${asCount(counters, 'tasks.sync.failure_retry.scheduled')}/${asCount(counters, 'tasks.sync.failure_retry.triggered')}/${asCount(counters, 'tasks.sync.failure_retry.failed')} (coalesced=${asCount(counters, 'tasks.sync.failure_retry.coalesced')} canceled=${asCount(counters, 'tasks.sync.failure_retry.canceled')} disabled=${asCount(counters, 'tasks.sync.failure_retry.disabled')})`);
+    const tagMapReloadAttempts = asCount(counters, 'tasks.sync.tag_map_reload.attempted');
+    const tagMapReloadSucceeded = asCount(counters, 'tasks.sync.tag_map_reload.succeeded');
+    const tagMapReloadFailed = asCount(counters, 'tasks.sync.tag_map_reload.failed');
+    if (tagMapReloadAttempts > 0 || tagMapReloadSucceeded > 0 || tagMapReloadFailed > 0) {
+        lines.push(`Task sync tag-map reload: attempts=${tagMapReloadAttempts} ok=${tagMapReloadSucceeded} failed=${tagMapReloadFailed}`);
+    }
+    return lines;
+}
+export function renderHealthReport(opts) {
+    const snap = opts.metrics.snapshot();
+    const counters = snap.counters;
+    const lines = [];
+    lines.push(`${opts.botDisplayName ?? 'Discoclaw'} Health`);
+    lines.push(`Uptime: ${formatUptime(Date.now() - snap.startedAt)}`);
+    lines.push(`Queue depth: ${opts.queueDepth}`);
+    lines.push(`Messages: ${counters['discord.message.received'] ?? 0} | Reactions: ${counters['discord.reaction.received'] ?? 0} add / ${counters['discord.reaction_remove.received'] ?? 0} remove`);
+    lines.push(`Invokes: started=${(counters['invoke.message.started'] ?? 0) + (counters['invoke.reaction.started'] ?? 0) + (counters['invoke.cron.started'] ?? 0)} ` +
+        `ok=${(counters['invoke.message.succeeded'] ?? 0) + (counters['invoke.reaction.succeeded'] ?? 0) + (counters['invoke.cron.succeeded'] ?? 0)} ` +
+        `failed=${(counters['invoke.message.failed'] ?? 0) + (counters['invoke.reaction.failed'] ?? 0) + (counters['invoke.cron.failed'] ?? 0)}`);
+    lines.push(`Actions: ok=${counters['actions.succeeded'] ?? 0} failed=${counters['actions.failed'] ?? 0}`);
+    lines.push(`Cron runs: ok=${counters['cron.run.success'] ?? 0} error=${counters['cron.run.error'] ?? 0} skipped=${counters['cron.run.skipped'] ?? 0}`);
+    lines.push(`Latency(ms): msg p50=${snap.latencies.message.p50Ms} p95=${snap.latencies.message.p95Ms}; ` +
+        `reaction p50=${snap.latencies.reaction.p50Ms} p95=${snap.latencies.reaction.p95Ms}; ` +
+        `cron p50=${snap.latencies.cron.p50Ms} p95=${snap.latencies.cron.p95Ms}`);
+    if (opts.mode === 'verbose') {
+        lines.push('');
+        lines.push('Config (safe)');
+        lines.push(`runtimeModel=${opts.config.runtimeModel} timeoutMs=${opts.config.runtimeTimeoutMs} tools=${opts.config.runtimeTools.join(',')}`);
+        lines.push(`runtimeSessions=${opts.config.useRuntimeSessions} toolAwareStreaming=${opts.config.toolAwareStreaming} maxConcurrent=${opts.config.maxConcurrentInvocations}`);
+        lines.push(`actions=${opts.config.discordActionsEnabled} summary=${opts.config.summaryEnabled} durableMemory=${opts.config.durableMemoryEnabled}`);
+        lines.push(`historyBudget=${opts.config.messageHistoryBudget} requireChannelContext=${opts.config.requireChannelContext} autoIndexContext=${opts.config.autoIndexChannelContext}`);
+        const tasksActive = opts.config.tasksActive;
+        const tasksEnabled = opts.config.tasksEnabled;
+        const tasksState = tasksActive ? 'active' : tasksEnabled ? 'degraded' : 'off';
+        lines.push(`reactionHandler=${opts.config.reactionHandlerEnabled} reactionRemoveHandler=${opts.config.reactionRemoveHandlerEnabled} cron=${opts.config.cronEnabled} tasks=${tasksState}`);
+        lines.push(`taskSyncPolicy: failureRetry=${opts.config.tasksSyncFailureRetryEnabled ? 'on' : 'off'} failureDelayMs=${opts.config.tasksSyncFailureRetryDelayMs} deferredDelayMs=${opts.config.tasksSyncDeferredRetryDelayMs}`);
+        lines.push(...formatTaskSyncVerboseLines(counters));
+        if (snap.memory) {
+            lines.push(renderMemoryLine(snap.memory));
+        }
+        const errorClasses = Object.keys(counters)
+            .filter((k) => k.includes('.error_class.'))
+            .sort();
+        if (errorClasses.length > 0) {
+            lines.push('Error classes:');
+            for (const key of errorClasses) {
+                lines.push(`- ${key}=${counters[key]}`);
+            }
+        }
+    }
+    return `\`\`\`text\n${lines.join('\n')}\n\`\`\``;
+}
+export function renderHealthToolsReport(opts) {
+    const lines = [];
+    lines.push(`${opts.botDisplayName ?? 'Discoclaw'} Tools`);
+    lines.push(`Permission tier: ${opts.permissionTier}`);
+    lines.push(`Effective tools: ${opts.effectiveTools.length > 0 ? opts.effectiveTools.join(', ') : '(none)'}`);
+    lines.push(`Configured runtime tools: ${opts.configuredRuntimeTools.length > 0 ? opts.configuredRuntimeTools.join(', ') : '(none)'}`);
+    return `\`\`\`text\n${lines.join('\n')}\n\`\`\``;
+}