discoclaw 0.1.0

package/dist/discord/audit-handler.js

@@ -0,0 +1,191 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { findPlanFile, parsePlanFileHeader, } from './plan-commands.js';
+import { appendAuditRound, buildAuditorPrompt } from './forge-commands.js';
+import { parseAuditVerdict } from './forge-audit-verdict.js';
+import { collectRuntimeText } from './runtime-utils.js';
+import { getSection, parsePlan } from './plan-parser.js';
+// ---------------------------------------------------------------------------
+// Structural audit checks (fast pre-flight gate)
+// ---------------------------------------------------------------------------
+const REQUIRED_SECTIONS = ['Objective', 'Scope', 'Changes', 'Risks', 'Testing'];
+export function auditPlanStructure(content) {
+    const concerns = [];
+    const parsed = parsePlan(content);
+    // Check for required sections
+    for (const section of REQUIRED_SECTIONS) {
+        const hasSection = parsed.sections.has(section);
+        if (!hasSection) {
+            concerns.push({
+                title: `Missing section: ${section}`,
+                description: `The plan is missing the required "## ${section}" section.`,
+                severity: 'high',
+            });
+            continue;
+        }
+        const body = getSection(parsed, section).trim();
+        // Check if the section has meaningful content (not just placeholder text)
+        if (!body || /^_.*_$/.test(body) || body.startsWith('(') || body.length < 10) {
+            concerns.push({
+                title: `Empty or placeholder: ${section}`,
+                description: `The "${section}" section appears to contain only placeholder text.`,
+                severity: 'medium',
+            });
+        }
+    }
+    // Check for a Changes section with file paths
+    const changesBody = getSection(parsed, 'Changes').trim();
+    if (changesBody) {
+        const hasFilePaths = /`[^`]+\.[a-z]+`/.test(changesBody);
+        if (changesBody.length > 10 && !hasFilePaths) {
+            concerns.push({
+                title: 'Changes section lacks file paths',
+                description: 'The Changes section does not reference specific file paths. Plans should list concrete file-by-file changes.',
+                severity: 'medium',
+            });
+        }
+    }
+    // Check plan status
+    const header = parsePlanFileHeader(content);
+    if (header && header.status === 'CLOSED') {
+        concerns.push({
+            title: 'Plan is closed',
+            description: 'This plan has been closed. Auditing a closed plan is unusual.',
+            severity: 'low',
+        });
+    }
+    return concerns;
+}
+export function deriveVerdict(concerns) {
+    const hasHigh = concerns.some((c) => c.severity === 'high');
+    const hasMedium = concerns.some((c) => c.severity === 'medium');
+    if (hasHigh)
+        return { maxSeverity: 'blocking', shouldLoop: true };
+    if (hasMedium)
+        return { maxSeverity: 'medium', shouldLoop: true };
+    if (concerns.length > 0)
+        return { maxSeverity: 'minor', shouldLoop: false };
+    return { maxSeverity: 'none', shouldLoop: false };
+}
+function formatStructuralNotes(concerns) {
+    if (concerns.length === 0)
+        return '';
+    const lines = ['## Structural Pre-flight', ''];
+    for (let i = 0; i < concerns.length; i++) {
+        const c = concerns[i];
+        lines.push(`**Concern ${i + 1}: ${c.title}**`);
+        lines.push(c.description);
+        lines.push(`**Severity: ${c.severity}**`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Max review number extraction (avoids duplicate round numbers)
+// ---------------------------------------------------------------------------
+export function maxReviewNumber(content) {
+    const matches = content.matchAll(/### Review (\d+)/g);
+    let max = 0;
+    for (const m of matches) {
+        const n = parseInt(m[1], 10);
+        if (n > max)
+            max = n;
+    }
+    return max;
+}
+// ---------------------------------------------------------------------------
+// Project context loader (inlined from ForgeOrchestrator pattern)
+// ---------------------------------------------------------------------------
+async function loadProjectContext(workspaceCwd) {
+    try {
+        const content = await fs.readFile(path.join(workspaceCwd, '.context', 'project.md'), 'utf-8');
+        return content.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// ---------------------------------------------------------------------------
+// Exported handler
+// ---------------------------------------------------------------------------
+/**
+ * Run a standalone audit against an existing plan: structural pre-flight
+ * followed by an AI-powered deep review. Appends a new review entry to
+ * the plan's Audit Log section.
+ *
+ * The writer lock is only held during the final write phase (not during
+ * the AI agent call) to avoid blocking other plan operations.
+ */
+export async function handlePlanAudit(opts) {
+    // 1. Find the plan file
+    const found = await findPlanFile(opts.plansDir, opts.planId);
+    if (!found)
+        return { ok: false, error: `Plan not found: ${opts.planId}` };
+    const planContent = await fs.readFile(found.filePath, 'utf-8');
+    // 2. Validate Audit Log section exists
+    if (!planContent.includes('## Audit Log')) {
+        return { ok: false, error: 'Plan file is missing an Audit Log section — cannot append audit.' };
+    }
+    // 3. Structural pre-flight (instant)
+    const structuralConcerns = auditPlanStructure(planContent);
+    const structuralVerdict = deriveVerdict(structuralConcerns);
+    // If structural audit finds high/medium issues, stop — no point burning tokens
+    if (structuralVerdict.shouldLoop) {
+        const structuralNotes = formatStructuralNotes(structuralConcerns);
+        const verdictLine = `**Verdict:** Needs revision.`;
+        const fullNotes = structuralNotes + verdictLine;
+        // Write under lock
+        const releaseLock = await opts.acquireWriterLock();
+        try {
+            const freshContent = await fs.readFile(found.filePath, 'utf-8');
+            const round = maxReviewNumber(freshContent) + 1;
+            const updated = appendAuditRound(freshContent, round, fullNotes, structuralVerdict);
+            const tmpPath = found.filePath + '.tmp';
+            await fs.writeFile(tmpPath, updated, 'utf-8');
+            await fs.rename(tmpPath, found.filePath);
+            return { ok: true, planId: found.header.planId, round, verdict: structuralVerdict };
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    // 4. Load project context for the auditor
+    const projectContext = await loadProjectContext(opts.cwd);
+    // 5. Determine preliminary round number (for the auditor prompt)
+    const preliminaryRound = maxReviewNumber(planContent) + 1;
+    // 6. Invoke AI auditor agent (outside the lock)
+    let auditOutput;
+    try {
+        const rt = opts.auditorRuntime ?? opts.runtime;
+        const auditorHasFileTools = rt.capabilities.has('tools_fs');
+        const readOnlyTools = ['Read', 'Glob', 'Grep'];
+        const auditorPrompt = buildAuditorPrompt(planContent, preliminaryRound, projectContext, { hasTools: auditorHasFileTools });
+        auditOutput = await collectRuntimeText(rt, auditorPrompt, opts.auditorModel, opts.cwd, auditorHasFileTools ? readOnlyTools : [], auditorHasFileTools ? [opts.cwd] : [], opts.timeoutMs);
+    }
+    catch (err) {
+        return { ok: false, error: `Auditor agent failed: ${String(err instanceof Error ? err.message : err)}` };
+    }
+    // 7. Parse the AI verdict
+    const aiVerdict = parseAuditVerdict(auditOutput);
+    // 8. Combine structural notes (low-severity only, since we passed the gate) with AI output
+    const structuralPrefix = formatStructuralNotes(structuralConcerns);
+    const combinedNotes = structuralPrefix
+        ? structuralPrefix + '## AI Audit\n\n' + auditOutput.trim()
+        : auditOutput.trim();
+    // The AI verdict is the one that matters (structural passed the gate)
+    const finalVerdict = aiVerdict;
+    // 9. Acquire lock, re-read, and write atomically
+    const releaseLock = await opts.acquireWriterLock();
+    try {
+        const freshContent = await fs.readFile(found.filePath, 'utf-8');
+        const round = maxReviewNumber(freshContent) + 1;
+        const updated = appendAuditRound(freshContent, round, combinedNotes, finalVerdict);
+        const tmpPath = found.filePath + '.tmp';
+        await fs.writeFile(tmpPath, updated, 'utf-8');
+        await fs.rename(tmpPath, found.filePath);
+        return { ok: true, planId: found.header.planId, round, verdict: finalVerdict };
+    }
+    finally {
+        releaseLock();
+    }
+}

package/dist/discord/audit-handler.test.js

@@ -0,0 +1,361 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { handlePlanAudit, auditPlanStructure, maxReviewNumber } from './audit-handler.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function makeTmpDir() {
+    return fs.mkdtemp(path.join(os.tmpdir(), 'audit-handler-test-'));
+}
+function makeMockRuntime(response) {
+    return {
+        id: 'claude_code',
+        capabilities: new Set(['streaming_text']),
+        invoke(_params) {
+            return (async function* () {
+                yield { type: 'text_final', text: response };
+            })();
+        },
+    };
+}
+function makeMockRuntimeError(message) {
+    return {
+        id: 'claude_code',
+        capabilities: new Set(['streaming_text']),
+        invoke(_params) {
+            return (async function* () {
+                yield { type: 'error', message };
+            })();
+        },
+    };
+}
+const MINIMAL_PLAN = `# Plan: Test plan
+
+**ID:** plan-099
+**Task:** workspace-test
+**Created:** 2026-02-13
+**Status:** APPROVED
+**Project:** discoclaw
+
+---
+
+## Objective
+
+Add a widget to the thing.
+
+## Scope
+
+**In:**
+- Add the widget module
+- Write tests
+
+**Out:**
+- Changing existing widgets
+
+## Changes
+
+### File-by-file breakdown
+
+- \`src/widget.ts\` — New file containing the widget implementation.
+- \`src/widget.test.ts\` — Tests for the widget.
+
+### New files
+- \`src/widget.ts\`
+- \`src/widget.test.ts\`
+
+### Deleted files
+_(none)_
+
+## Risks
+
+- Widget might conflict with existing gizmo module.
+
+## Testing
+
+- Unit tests for widget creation, deletion, and update.
+- Integration test with the gizmo module.
+
+## Dependencies
+
+_(none)_
+
+---
+
+## Audit Log
+
+---
+
+## Implementation Notes
+
+_Filled in during/after implementation._
+`;
+function makeLockFn() {
+    const state = { released: false };
+    const fn = async () => {
+        return () => { state.released = true; };
+    };
+    return { fn, get released() { return state.released; } };
+}
+async function writeTestPlan(plansDir, content = MINIMAL_PLAN) {
+    await fs.mkdir(plansDir, { recursive: true });
+    const filePath = path.join(plansDir, 'plan-099-test-plan.md');
+    await fs.writeFile(filePath, content, 'utf-8');
+    return filePath;
+}
+function baseOpts(plansDir, runtime, lock, workspaceCwd, cwd) {
+    return {
+        planId: 'plan-099',
+        plansDir,
+        cwd: cwd ?? workspaceCwd,
+        workspaceCwd,
+        runtime,
+        auditorModel: 'test-model',
+        timeoutMs: 30_000,
+        acquireWriterLock: lock.fn,
+    };
+}
+// ---------------------------------------------------------------------------
+// Unit tests: auditPlanStructure
+// ---------------------------------------------------------------------------
+describe('auditPlanStructure', () => {
+    it('returns no concerns for a complete plan', () => {
+        const concerns = auditPlanStructure(MINIMAL_PLAN);
+        expect(concerns).toEqual([]);
+    });
+    it('flags missing required sections', () => {
+        const content = `# Plan: Test\n\n## Objective\n\nDo the thing.\n\n## Scope\n\n**In:** stuff\n\n---\n\n## Audit Log\n`;
+        const concerns = auditPlanStructure(content);
+        const titles = concerns.map((c) => c.title);
+        expect(titles).toContain('Missing section: Changes');
+        expect(titles).toContain('Missing section: Risks');
+        expect(titles).toContain('Missing section: Testing');
+    });
+    it('flags placeholder sections', () => {
+        const content = MINIMAL_PLAN.replace('## Risks\n\n- Widget might conflict with existing gizmo module.', '## Risks\n\n_(TBD)_');
+        const concerns = auditPlanStructure(content);
+        expect(concerns.some((c) => c.title === 'Empty or placeholder: Risks')).toBe(true);
+    });
+    it('treats present-but-empty required sections as placeholder, not missing', () => {
+        const content = MINIMAL_PLAN.replace('## Risks\n\n- Widget might conflict with existing gizmo module.', '## Risks\n');
+        const concerns = auditPlanStructure(content);
+        expect(concerns.some((c) => c.title === 'Empty or placeholder: Risks')).toBe(true);
+        expect(concerns.some((c) => c.title === 'Missing section: Risks')).toBe(false);
+    });
+    it('flags Changes section without file paths', () => {
+        const content = MINIMAL_PLAN.replace(/## Changes[\s\S]*?## Risks/m, '## Changes\n\nWe will make some changes to the codebase to improve things significantly.\n\n## Risks');
+        const concerns = auditPlanStructure(content);
+        expect(concerns.some((c) => c.title === 'Changes section lacks file paths')).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Unit tests: maxReviewNumber
+// ---------------------------------------------------------------------------
+describe('maxReviewNumber', () => {
+    it('returns 0 when no reviews exist', () => {
+        expect(maxReviewNumber(MINIMAL_PLAN)).toBe(0);
+    });
+    it('returns the max review number', () => {
+        const content = MINIMAL_PLAN.replace('## Audit Log\n', '## Audit Log\n\n### Review 1 — 2026-02-13\nStuff\n\n### Review 3 — 2026-02-13\nMore stuff\n');
+        expect(maxReviewNumber(content)).toBe(3);
+    });
+});
+// ---------------------------------------------------------------------------
+// Integration tests: handlePlanAudit
+// ---------------------------------------------------------------------------
+describe('handlePlanAudit', () => {
+    let tmpDir;
+    let plansDir;
+    beforeEach(async () => {
+        tmpDir = await makeTmpDir();
+        plansDir = path.join(tmpDir, 'plans');
+    });
+    it('happy path: structural passes, AI audit appends review', async () => {
+        await writeTestPlan(plansDir);
+        const runtime = makeMockRuntime('No concerns found.\n\n**Verdict:** Ready to approve.');
+        const lock = makeLockFn();
+        const result = await handlePlanAudit(baseOpts(plansDir, runtime, lock, tmpDir));
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.round).toBe(1);
+            // parseAuditVerdict returns 'minor' for "ready to approve" with no severity markers
+            expect(result.verdict.maxSeverity).toBe('minor');
+            expect(result.verdict.shouldLoop).toBe(false);
+        }
+        // Verify the plan file was updated
+        const updated = await fs.readFile(path.join(plansDir, 'plan-099-test-plan.md'), 'utf-8');
+        expect(updated).toContain('### Review 1');
+        expect(lock.released).toBe(true);
+    });
+    it('plan not found', async () => {
+        await fs.mkdir(plansDir, { recursive: true });
+        const runtime = makeMockRuntime('unused');
+        const lock = makeLockFn();
+        const result = await handlePlanAudit(baseOpts(plansDir, runtime, lock, tmpDir));
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error).toContain('Plan not found');
+        }
+    });
+    it('missing Audit Log section', async () => {
+        const noAuditLog = MINIMAL_PLAN.replace('## Audit Log\n', '');
+        await writeTestPlan(plansDir, noAuditLog);
+        const runtime = makeMockRuntime('unused');
+        const lock = makeLockFn();
+        const result = await handlePlanAudit(baseOpts(plansDir, runtime, lock, tmpDir));
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error).toContain('Audit Log');
+        }
+    });
+    it('structural gate stops on high severity — no AI call', async () => {
+        // Plan missing Changes, Risks, Testing sections
+        const badPlan = `# Plan: Bad plan
+
+**ID:** plan-099
+**Task:** workspace-test
+**Created:** 2026-02-13
+**Status:** DRAFT
+**Project:** discoclaw
+
+---
+
+## Objective
+
+Do something.
+
+## Scope
+
+**In:** stuff
+
+---
+
+## Audit Log
+
+---
+
+## Implementation Notes
+
+_Filled in during/after implementation._
+`;
+        await writeTestPlan(plansDir, badPlan);
+        const invokespy = vi.fn();
+        const runtime = {
+            id: 'claude_code',
+            capabilities: new Set(['streaming_text']),
+            invoke: invokespy,
+        };
+        const lock = makeLockFn();
+        const result = await handlePlanAudit(baseOpts(plansDir, runtime, lock, tmpDir));
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.verdict.maxSeverity).toBe('blocking');
+            expect(result.verdict.shouldLoop).toBe(true);
+        }
+        // AI agent should NOT have been called
+        expect(invokespy).not.toHaveBeenCalled();
+        expect(lock.released).toBe(true);
+    });
+    it('AI agent failure returns error without writing', async () => {
+        await writeTestPlan(plansDir);
+        const runtime = makeMockRuntimeError('Model overloaded');
+        const lock = makeLockFn();
+        const result = await handlePlanAudit(baseOpts(plansDir, runtime, lock, tmpDir));
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error).toContain('Auditor agent failed');
+        }
+        // Plan file should be untouched
+        const content = await fs.readFile(path.join(plansDir, 'plan-099-test-plan.md'), 'utf-8');
+        expect(content).not.toContain('### Review');
+    });
+    it('round numbering with existing reviews', async () => {
+        const withReviews = MINIMAL_PLAN.replace('## Audit Log\n', '## Audit Log\n\n### Review 1 — 2026-02-13\n**Status:** COMPLETE\nStuff\n\n### Review 2 — 2026-02-13\n**Status:** COMPLETE\nMore stuff\n');
+        await writeTestPlan(plansDir, withReviews);
+        const runtime = makeMockRuntime('No concerns.\n\n**Verdict:** Ready to approve.');
+        const lock = makeLockFn();
+        const result = await handlePlanAudit(baseOpts(plansDir, runtime, lock, tmpDir));
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.round).toBe(3);
+        }
+    });
+    it('lock released even on write failure', async () => {
+        await writeTestPlan(plansDir);
+        const runtime = makeMockRuntime('No concerns.\n\n**Verdict:** Ready to approve.');
+        const lock = makeLockFn();
+        // Make the plans directory read-only so the .tmp file creation fails.
+        // chmod on the file alone won't work — rename(2) only needs directory
+        // write permission, not file write permission.
+        await fs.chmod(plansDir, 0o555);
+        // handlePlanAudit will throw from the write phase (EACCES on .tmp creation),
+        // but the try/finally must still release the lock.
+        await expect(handlePlanAudit(baseOpts(plansDir, runtime, lock, tmpDir))).rejects.toThrow();
+        expect(lock.released).toBe(true);
+        // Plan file should be unchanged (write never completed)
+        await fs.chmod(plansDir, 0o755);
+        const content = await fs.readFile(path.join(plansDir, 'plan-099-test-plan.md'), 'utf-8');
+        expect(content).not.toContain('### Review');
+    });
+    it('tools_fs runtime receives tools and addDirs pointing to project cwd', async () => {
+        await writeTestPlan(plansDir);
+        const invokeSpy = vi.fn();
+        const runtime = {
+            id: 'codex',
+            capabilities: new Set(['streaming_text', 'tools_fs']),
+            invoke(params) {
+                invokeSpy(params);
+                return (async function* () {
+                    yield { type: 'text_final', text: 'No concerns.\n\n**Verdict:** Ready to approve.' };
+                })();
+            },
+        };
+        const lock = makeLockFn();
+        const projectCwd = path.join(tmpDir, 'project-root');
+        await fs.mkdir(projectCwd, { recursive: true });
+        const result = await handlePlanAudit(baseOpts(plansDir, runtime, lock, tmpDir, projectCwd));
+        expect(result.ok).toBe(true);
+        expect(invokeSpy).toHaveBeenCalledTimes(1);
+        const params = invokeSpy.mock.calls[0][0];
+        // Should receive the read-only tool list
+        expect(params.tools).toEqual(['Read', 'Glob', 'Grep']);
+        // addDirs should point to the project cwd, not workspaceCwd
+        expect(params.addDirs).toEqual([projectCwd]);
+    });
+    it('non-tools_fs runtime receives no tools or addDirs', async () => {
+        await writeTestPlan(plansDir);
+        const invokeSpy = vi.fn();
+        const runtime = {
+            id: 'codex',
+            capabilities: new Set(['streaming_text']),
+            invoke(params) {
+                invokeSpy(params);
+                return (async function* () {
+                    yield { type: 'text_final', text: 'No concerns.\n\n**Verdict:** Ready to approve.' };
+                })();
+            },
+        };
+        const lock = makeLockFn();
+        const result = await handlePlanAudit(baseOpts(plansDir, runtime, lock, tmpDir));
+        expect(result.ok).toBe(true);
+        expect(invokeSpy).toHaveBeenCalledTimes(1);
+        const params = invokeSpy.mock.calls[0][0];
+        // Should receive empty tools
+        expect(params.tools).toEqual([]);
+        // addDirs should be undefined (collectRuntimeText converts [] to undefined)
+        expect(params.addDirs).toBeUndefined();
+    });
+    it('empty plan ID', async () => {
+        await fs.mkdir(plansDir, { recursive: true });
+        const runtime = makeMockRuntime('unused');
+        const lock = makeLockFn();
+        const opts = baseOpts(plansDir, runtime, lock, tmpDir);
+        opts.planId = '';
+        const result = await handlePlanAudit(opts);
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error).toContain('not found');
+        }
+    });
+});

package/dist/discord/bot.js

@@ -0,0 +1,141 @@
+import { Client, GatewayIntentBits, Partials } from 'discord.js';
+import { isAllowlisted } from './allowlist.js';
+import { KeyedQueue } from './keyed-queue.js';
+function discordSessionKey(msg) {
+    if (msg.isDm)
+        return `discord:dm:${msg.authorId}`;
+    return `discord:channel:${msg.channelId}`;
+}
+function splitDiscord(text, limit = 2000) {
+    // Minimal fence-safe markdown chunking.
+    const normalized = text.replace(/\r\n?/g, '\n');
+    if (normalized.length <= limit)
+        return [normalized];
+    const rawLines = normalized.split('\n');
+    const chunks = [];
+    let cur = '';
+    let inFence = false;
+    let fenceHeader = '```';
+    const ensureFenceOpen = () => {
+        if (cur)
+            return;
+        if (inFence)
+            cur = `${fenceHeader}\n`;
+    };
+    const flush = () => {
+        if (!cur)
+            return;
+        if (inFence && !cur.trimEnd().endsWith('```')) {
+            const close = '\n```';
+            if (cur.length + close.length <= limit) {
+                cur += close;
+            }
+        }
+        chunks.push(cur);
+        cur = '';
+    };
+    const appendLine = (line) => {
+        ensureFenceOpen();
+        const sep = cur.length > 0 ? '\n' : '';
+        cur += sep + line;
+    };
+    for (const line of rawLines) {
+        const nextLen = (cur.length ? cur.length + 1 : 0) + line.length;
+        if (nextLen > limit) {
+            flush();
+            // Reopen fence if we flushed mid-fence.
+            ensureFenceOpen();
+        }
+        // If the line itself is too long, hard split.
+        if (line.length > limit) {
+            let rest = line;
+            while (rest.length > 0) {
+                const room = Math.max(1, limit - (cur.length ? cur.length + 1 : 0));
+                const take = rest.slice(0, room);
+                appendLine(take);
+                rest = rest.slice(room);
+                if (rest.length > 0) {
+                    flush();
+                    ensureFenceOpen();
+                }
+            }
+        }
+        else {
+            appendLine(line);
+        }
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith('```')) {
+            if (!inFence) {
+                inFence = true;
+                fenceHeader = trimmed.trimEnd();
+            }
+            else {
+                inFence = false;
+                fenceHeader = '```';
+            }
+        }
+        // If we are in a fence and we're close to the limit, proactively flush
+        // to reduce the chance of an un-closable fence close.
+        if (inFence && cur.length >= limit - 8) {
+            flush();
+            // Next line will reopen.
+        }
+    }
+    flush();
+    return chunks.filter((c) => c.trim().length > 0);
+}
+export async function startDiscordBot(params) {
+    const client = new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.DirectMessages,
+        ],
+        partials: [Partials.Channel],
+    });
+    const queue = new KeyedQueue();
+    client.on('messageCreate', async (msg) => {
+        if (!msg.author || msg.author.bot)
+            return;
+        if (!isAllowlisted(params.allowUserIds, msg.author.id))
+            return;
+        const isDm = msg.guildId == null;
+        const sessionKey = discordSessionKey({
+            channelId: msg.channelId,
+            authorId: msg.author.id,
+            isDm,
+        });
+        await queue.run(sessionKey, async () => {
+            const sessionId = await params.sessionManager.getOrCreate(sessionKey);
+            const reply = await msg.reply('...');
+            let finalText = '';
+            for await (const evt of params.runtime.invoke({
+                prompt: msg.content,
+                model: 'opus',
+                cwd: params.workspaceCwd,
+                sessionId,
+                tools: ['Bash', 'Read', 'Edit', 'WebSearch', 'WebFetch'],
+                timeoutMs: 10 * 60_000,
+            })) {
+                if (evt.type === 'text_final') {
+                    finalText = evt.text;
+                }
+                else if (evt.type === 'error') {
+                    finalText = `Error: ${evt.message}`;
+                }
+                else if (evt.type === 'text_delta' && !finalText) {
+                    // Only use deltas when we don't get a final text payload.
+                    finalText += evt.text;
+                }
+            }
+            const chunks = splitDiscord(finalText || '(no output)');
+            await reply.edit(chunks[0] ?? '(no output)');
+            for (const extra of chunks.slice(1)) {
+                await msg.channel.send(extra);
+            }
+        });
+    });
+    await client.login(params.token);
+    return client;
+}