discoclaw 0.1.0

package/dist/discord/status-command.test.js

@@ -0,0 +1,341 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { parseStatusCommand, renderStatusReport, collectStatusSnapshot, } from './status-command.js';
+import * as credentialCheck from '../health/credential-check.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeSnapshot(overrides = {}) {
+    return {
+        uptimeMs: 3_661_000, // 1h 1m 1s
+        lastMessageAt: Date.now() - 90_000, // 1m 30s ago
+        crons: [],
+        openTaskCount: 0,
+        durableItemCount: 0,
+        rollingSummaryCharCount: 0,
+        apiChecks: [],
+        paFiles: [],
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// parseStatusCommand
+// ---------------------------------------------------------------------------
+describe('parseStatusCommand', () => {
+    it('returns true for !status', () => {
+        expect(parseStatusCommand('!status')).toBe(true);
+    });
+    it('is case-insensitive', () => {
+        expect(parseStatusCommand('!STATUS')).toBe(true);
+        expect(parseStatusCommand('!Status')).toBe(true);
+    });
+    it('trims surrounding whitespace', () => {
+        expect(parseStatusCommand('  !status  ')).toBe(true);
+    });
+    it('returns null for non-status commands', () => {
+        expect(parseStatusCommand('!health')).toBeNull();
+        expect(parseStatusCommand('!memory')).toBeNull();
+        expect(parseStatusCommand('hello')).toBeNull();
+        expect(parseStatusCommand('')).toBeNull();
+    });
+    it('returns null for !status with subcommands', () => {
+        expect(parseStatusCommand('!status verbose')).toBeNull();
+        expect(parseStatusCommand('!status foo')).toBeNull();
+    });
+    it('handles non-string input gracefully', () => {
+        expect(parseStatusCommand(undefined)).toBeNull();
+        expect(parseStatusCommand(null)).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// renderStatusReport
+// ---------------------------------------------------------------------------
+describe('renderStatusReport', () => {
+    it('renders uptime correctly', () => {
+        const out = renderStatusReport(makeSnapshot({ uptimeMs: 3_661_000 }));
+        expect(out).toContain('Uptime: 1h 1m 1s');
+    });
+    it('renders last message when present', () => {
+        const snap = makeSnapshot({ lastMessageAt: Date.now() - 90_000 });
+        const out = renderStatusReport(snap);
+        expect(out).toMatch(/Last message: \d+m ago/);
+    });
+    it('renders "none since startup" when lastMessageAt is null', () => {
+        const out = renderStatusReport(makeSnapshot({ lastMessageAt: null }));
+        expect(out).toContain('Last message: none since startup');
+    });
+    it('renders crons=none when empty', () => {
+        const out = renderStatusReport(makeSnapshot({ crons: [] }));
+        expect(out).toContain('Crons: none');
+    });
+    it('renders cron list with next run times', () => {
+        // Use 10m + 30s buffer so the "in Xm" label is stable regardless of test latency.
+        const futureDate = new Date(Date.now() + 10 * 60_000 + 30_000);
+        const snap = makeSnapshot({
+            crons: [
+                { name: 'morning-report', schedule: '0 7 * * 1-5', nextRun: futureDate },
+                { name: 'weekly-digest', schedule: '0 9 * * 1', nextRun: null },
+                { name: 'manual-job', schedule: undefined, nextRun: null },
+            ],
+        });
+        const out = renderStatusReport(snap);
+        expect(out).toContain('Crons (3):');
+        expect(out).toContain('morning-report: next=in 10m');
+        expect(out).toContain('weekly-digest: next=stopped');
+        expect(out).toContain('manual-job: next=manual/webhook');
+    });
+    it('renders imminent next run when date is in the past', () => {
+        const pastDate = new Date(Date.now() - 1000);
+        const snap = makeSnapshot({
+            crons: [{ name: 'overdue', schedule: '* * * * *', nextRun: pastDate }],
+        });
+        const out = renderStatusReport(snap);
+        expect(out).toContain('overdue: next=imminent');
+    });
+    it('renders open task count', () => {
+        const out = renderStatusReport(makeSnapshot({ openTaskCount: 7 }));
+        expect(out).toContain('Open tasks: 7');
+    });
+    it('renders memory stats', () => {
+        const out = renderStatusReport(makeSnapshot({ durableItemCount: 42, rollingSummaryCharCount: 1234 }));
+        expect(out).toContain('Memory: durable=42 items, summaries=1234 chars');
+    });
+    it('renders API check results', () => {
+        const snap = makeSnapshot({
+            apiChecks: [
+                { name: 'discord-token', status: 'ok' },
+                { name: 'openai-key', status: 'skip' },
+            ],
+        });
+        const out = renderStatusReport(snap);
+        expect(out).toContain('API: discord-token: ok, openai-key: skip');
+    });
+    it('renders API FAIL with message', () => {
+        const snap = makeSnapshot({
+            apiChecks: [
+                { name: 'discord-token', status: 'fail', message: 'invalid or revoked token (401)' },
+            ],
+        });
+        const out = renderStatusReport(snap);
+        expect(out).toContain('discord-token: FAIL (invalid or revoked token (401))');
+    });
+    it('renders API: no checks when array is empty', () => {
+        const out = renderStatusReport(makeSnapshot({ apiChecks: [] }));
+        expect(out).toContain('API: no checks');
+    });
+    it('renders workspace PA as ok when all files exist', () => {
+        const snap = makeSnapshot({
+            paFiles: [
+                { label: 'pa.md', exists: true },
+                { label: 'pa-safety.md', exists: true },
+            ],
+        });
+        const out = renderStatusReport(snap);
+        expect(out).toContain('Workspace PA: ok');
+        expect(out).toContain('pa.md: ok');
+        expect(out).toContain('pa-safety.md: ok');
+    });
+    it('renders workspace PA as DEGRADED when a file is missing', () => {
+        const snap = makeSnapshot({
+            paFiles: [
+                { label: 'pa.md', exists: true },
+                { label: 'pa-safety.md', exists: false },
+            ],
+        });
+        const out = renderStatusReport(snap);
+        expect(out).toContain('Workspace PA: DEGRADED');
+        expect(out).toContain('pa-safety.md: MISSING');
+    });
+    it('renders workspace PA as DEGRADED when no files configured', () => {
+        const out = renderStatusReport(makeSnapshot({ paFiles: [] }));
+        expect(out).toContain('Workspace PA: DEGRADED');
+        expect(out).toContain('none configured');
+    });
+    it('uses custom bot display name', () => {
+        const out = renderStatusReport(makeSnapshot(), 'MyBot');
+        expect(out).toContain('MyBot Status');
+        expect(out).not.toContain('Discoclaw Status');
+    });
+    it('defaults to Discoclaw when no name provided', () => {
+        const out = renderStatusReport(makeSnapshot());
+        expect(out).toContain('Discoclaw Status');
+    });
+    it('wraps output in a fenced text code block', () => {
+        const out = renderStatusReport(makeSnapshot());
+        expect(out).toMatch(/^```text\n/);
+        expect(out).toMatch(/\n```$/);
+    });
+    it('renders next run in days for distant future', () => {
+        const farFuture = new Date(Date.now() + 2 * 24 * 60 * 60_000 + 3 * 60 * 60_000); // 2d 3h
+        const snap = makeSnapshot({
+            crons: [{ name: 'rare-job', schedule: '0 0 * * 0', nextRun: farFuture }],
+        });
+        const out = renderStatusReport(snap);
+        expect(out).toContain('rare-job: next=in 2d');
+    });
+});
+// ---------------------------------------------------------------------------
+// collectStatusSnapshot
+// ---------------------------------------------------------------------------
+describe('collectStatusSnapshot', () => {
+    beforeEach(() => {
+        vi.spyOn(credentialCheck, 'checkDiscordToken').mockResolvedValue({
+            name: 'discord-token',
+            status: 'ok',
+        });
+        vi.spyOn(credentialCheck, 'checkOpenAiKey').mockResolvedValue({
+            name: 'openai-key',
+            status: 'skip',
+        });
+        vi.spyOn(credentialCheck, 'checkOpenRouterKey').mockResolvedValue({
+            name: 'openrouter-key',
+            status: 'skip',
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    function baseOpts(overrides = {}) {
+        return {
+            startedAt: Date.now() - 60_000,
+            lastMessageAt: null,
+            scheduler: null,
+            taskStore: null,
+            durableDataDir: null,
+            summaryDataDir: null,
+            discordToken: 'test-token',
+            paFilePaths: [],
+            ...overrides,
+        };
+    }
+    it('returns uptime based on startedAt', async () => {
+        const startedAt = Date.now() - 5000;
+        const snap = await collectStatusSnapshot(baseOpts({ startedAt }));
+        expect(snap.uptimeMs).toBeGreaterThanOrEqual(5000);
+        expect(snap.uptimeMs).toBeLessThan(10_000);
+    });
+    it('passes lastMessageAt through unchanged', async () => {
+        const ts = Date.now() - 1234;
+        const snap = await collectStatusSnapshot(baseOpts({ lastMessageAt: ts }));
+        expect(snap.lastMessageAt).toBe(ts);
+    });
+    it('returns empty crons when scheduler is null', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ scheduler: null }));
+        expect(snap.crons).toEqual([]);
+    });
+    it('delegates cron list to scheduler.listJobs()', async () => {
+        const mockJobs = [{ id: 'j1', name: 'test-job', schedule: '* * * * *', timezone: 'UTC', nextRun: null }];
+        const mockScheduler = { listJobs: vi.fn().mockReturnValue(mockJobs) };
+        const snap = await collectStatusSnapshot(baseOpts({ scheduler: mockScheduler }));
+        expect(mockScheduler.listJobs).toHaveBeenCalledOnce();
+        expect(snap.crons).toEqual(mockJobs);
+    });
+    it('returns 0 open tasks when taskStore is null', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ taskStore: null }));
+        expect(snap.openTaskCount).toBe(0);
+    });
+    it('delegates task count to taskStore.list()', async () => {
+        const mockStore = { list: vi.fn().mockReturnValue([{}, {}, {}]) };
+        const snap = await collectStatusSnapshot(baseOpts({ taskStore: mockStore }));
+        expect(snap.openTaskCount).toBe(3);
+    });
+    it('returns 0 durable items when durableDataDir is null', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ durableDataDir: null }));
+        expect(snap.durableItemCount).toBe(0);
+    });
+    it('returns 0 summary chars when summaryDataDir is null', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ summaryDataDir: null }));
+        expect(snap.rollingSummaryCharCount).toBe(0);
+    });
+    it('includes apiChecks from credential check functions', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ discordToken: 'tok', openaiApiKey: 'key' }));
+        expect(credentialCheck.checkDiscordToken).toHaveBeenCalledWith('tok');
+        expect(credentialCheck.checkOpenAiKey).toHaveBeenCalledWith({ apiKey: 'key', baseUrl: undefined });
+        expect(snap.apiChecks).toHaveLength(2);
+        expect(snap.apiChecks[0]).toEqual({ name: 'discord-token', status: 'ok' });
+        expect(snap.apiChecks[1]).toEqual({ name: 'openai-key', status: 'skip' });
+    });
+    it('passes openaiBaseUrl to checkOpenAiKey', async () => {
+        await collectStatusSnapshot(baseOpts({ openaiApiKey: 'key', openaiBaseUrl: 'https://example.com/v1' }));
+        expect(credentialCheck.checkOpenAiKey).toHaveBeenCalledWith({
+            apiKey: 'key',
+            baseUrl: 'https://example.com/v1',
+        });
+    });
+    it('returns paFiles with exists=false for missing paths', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({
+            paFilePaths: [
+                { label: 'pa.md', path: '/nonexistent/path/pa.md' },
+                { label: 'pa-safety.md', path: '/nonexistent/path/pa-safety.md' },
+            ],
+        }));
+        expect(snap.paFiles).toEqual([
+            { label: 'pa.md', exists: false },
+            { label: 'pa-safety.md', exists: false },
+        ]);
+    });
+    it('handles API check failure gracefully — snapshot still resolves', async () => {
+        vi.spyOn(credentialCheck, 'checkDiscordToken').mockResolvedValue({
+            name: 'discord-token',
+            status: 'fail',
+            message: 'network error: timeout',
+        });
+        const snap = await collectStatusSnapshot(baseOpts());
+        expect(snap.apiChecks[0]?.status).toBe('fail');
+    });
+    it('handles non-existent durableDataDir without throwing', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ durableDataDir: '/tmp/discoclaw-test-nonexistent-durable-dir-xyz' }));
+        expect(snap.durableItemCount).toBe(0);
+    });
+    it('handles non-existent summaryDataDir without throwing', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ summaryDataDir: '/tmp/discoclaw-test-nonexistent-summary-dir-xyz' }));
+        expect(snap.rollingSummaryCharCount).toBe(0);
+    });
+    it('skips openai check and omits it from apiChecks when openai is not in activeProviders', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ activeProviders: new Set(['claude']) }));
+        expect(credentialCheck.checkOpenAiKey).not.toHaveBeenCalled();
+        expect(snap.apiChecks).toHaveLength(1);
+        expect(snap.apiChecks[0]).toEqual({ name: 'discord-token', status: 'ok' });
+    });
+    it('runs openai check when openai is in activeProviders', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ openaiApiKey: 'key', activeProviders: new Set(['openai']) }));
+        expect(credentialCheck.checkOpenAiKey).toHaveBeenCalledWith({ apiKey: 'key', baseUrl: undefined });
+        expect(snap.apiChecks).toHaveLength(2);
+        expect(snap.apiChecks[1]).toEqual({ name: 'openai-key', status: 'skip' });
+    });
+    it('skips openrouter check and omits it from apiChecks when openrouter is not in activeProviders', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ openrouterApiKey: 'sk-or-key', activeProviders: new Set(['claude']) }));
+        expect(credentialCheck.checkOpenRouterKey).not.toHaveBeenCalled();
+        expect(snap.apiChecks).toHaveLength(1);
+        expect(snap.apiChecks[0]).toEqual({ name: 'discord-token', status: 'ok' });
+    });
+    it('runs openrouter check when openrouter is in activeProviders', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({ openrouterApiKey: 'sk-or-key', activeProviders: new Set(['openrouter']) }));
+        expect(credentialCheck.checkOpenRouterKey).toHaveBeenCalledWith({
+            apiKey: 'sk-or-key',
+            baseUrl: undefined,
+        });
+        expect(snap.apiChecks).toHaveLength(2);
+        expect(snap.apiChecks[1]).toEqual({ name: 'openrouter-key', status: 'skip' });
+    });
+    it('passes openrouterBaseUrl to checkOpenRouterKey', async () => {
+        await collectStatusSnapshot(baseOpts({
+            openrouterApiKey: 'sk-or-key',
+            openrouterBaseUrl: 'https://custom-or.example.com/v1',
+            activeProviders: new Set(['openrouter']),
+        }));
+        expect(credentialCheck.checkOpenRouterKey).toHaveBeenCalledWith({
+            apiKey: 'sk-or-key',
+            baseUrl: 'https://custom-or.example.com/v1',
+        });
+    });
+    it('runs both openai and openrouter checks when both are in activeProviders', async () => {
+        const snap = await collectStatusSnapshot(baseOpts({
+            openaiApiKey: 'sk-key',
+            openrouterApiKey: 'sk-or-key',
+            activeProviders: new Set(['openai', 'openrouter']),
+        }));
+        expect(credentialCheck.checkOpenAiKey).toHaveBeenCalled();
+        expect(credentialCheck.checkOpenRouterKey).toHaveBeenCalled();
+        expect(snap.apiChecks).toHaveLength(3);
+    });
+});

package/dist/discord/streaming-progress.js

@@ -0,0 +1,107 @@
+import { ToolAwareQueue } from './tool-aware-queue.js';
+import { selectStreamingOutput } from './output-utils.js';
+import { NO_MENTIONS } from './allowed-mentions.js';
+/** The faster edit interval used for streaming preview edits (matches normal message handler). */
+const STREAMING_EDIT_INTERVAL_MS = 1250;
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Creates a streaming progress controller for a Discord message.
+ *
+ * The controller wraps a `ToolAwareQueue` to track live tool activity and
+ * streaming text, driving periodic Discord message edits via
+ * `selectStreamingOutput`. Static progress text (phase transitions, etc.)
+ * is forwarded through `onProgress`, which also resets the queue so
+ * streaming state from the previous phase does not bleed into the next.
+ *
+ * @param progressReply  The Discord message to edit in place.
+ * @param progressThrottleMs  Minimum ms between static progress edits (forgeProgressThrottleMs).
+ */
+export function createStreamingProgress(progressReply, progressThrottleMs) {
+    // Streaming state driven by the ToolAwareQueue
+    let activityLabel = '';
+    let deltaText = '';
+    let finalText = '';
+    let statusTick = 0;
+    let lastStreamEditAt = 0;
+    let progressMessageGone = false;
+    const startedAt = Date.now();
+    // Static-progress throttle state (mirrors the existing onProgress pattern)
+    let lastStaticEditAt = 0;
+    // Current queue instance — replaced on each onProgress call
+    let queue = createQueue();
+    // Interval that drives streaming preview edits
+    const interval = setInterval(() => {
+        void maybeStreamEdit(false);
+    }, STREAMING_EDIT_INTERVAL_MS);
+    function createQueue() {
+        return new ToolAwareQueue((action) => {
+            if (action.type === 'show_activity') {
+                activityLabel = action.label;
+                deltaText = '';
+            }
+            else if (action.type === 'stream_text') {
+                deltaText += action.text;
+            }
+            else if (action.type === 'set_final') {
+                finalText = action.text;
+                deltaText = '';
+                activityLabel = '';
+            }
+        });
+    }
+    async function maybeStreamEdit(force) {
+        if (progressMessageGone)
+            return;
+        const now = Date.now();
+        if (!force && now - lastStreamEditAt < STREAMING_EDIT_INTERVAL_MS)
+            return;
+        // Only render when there is something streaming to show
+        if (!activityLabel && !deltaText && !finalText)
+            return;
+        lastStreamEditAt = now;
+        const content = selectStreamingOutput({
+            deltaText,
+            activityLabel,
+            finalText,
+            statusTick: statusTick++,
+            elapsedMs: now - startedAt,
+        });
+        try {
+            await progressReply.edit({ content, allowedMentions: NO_MENTIONS });
+        }
+        catch {
+            // ignore Discord edit errors during streaming
+        }
+    }
+    const onEvent = (evt) => {
+        queue.handleEvent(evt);
+    };
+    const onProgress = async (msg, opts) => {
+        if (progressMessageGone)
+            return;
+        const now = Date.now();
+        if (!opts?.force && now - lastStaticEditAt < progressThrottleMs)
+            return;
+        lastStaticEditAt = now;
+        // Reset streaming state for the new phase boundary
+        queue.dispose();
+        activityLabel = '';
+        deltaText = '';
+        finalText = '';
+        queue = createQueue();
+        try {
+            await progressReply.edit({ content: msg, allowedMentions: NO_MENTIONS });
+        }
+        catch (editErr) {
+            if (editErr?.code === 10008)
+                progressMessageGone = true;
+        }
+    };
+    const dispose = () => {
+        clearInterval(interval);
+        queue.dispose();
+    };
+    return { onEvent, onProgress, dispose };
+}

package/dist/discord/streaming-progress.test.js

@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createStreamingProgress } from './streaming-progress.js';
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+function makeMessage() {
+    const edits = [];
+    const message = {
+        edit: vi.fn(async (opts) => {
+            edits.push(opts.content);
+        }),
+        edits,
+    };
+    return message;
+}
+describe('createStreamingProgress', () => {
+    it('onProgress edits the message with the provided text', async () => {
+        const message = makeMessage();
+        const ctrl = createStreamingProgress(message, 0);
+        await ctrl.onProgress('Phase 1 running...');
+        expect(message.edit).toHaveBeenCalledTimes(1);
+        expect(message.edits[0]).toBe('Phase 1 running...');
+        ctrl.dispose();
+    });
+    it('onProgress respects the throttle when force is not set', async () => {
+        const message = makeMessage();
+        const ctrl = createStreamingProgress(message, 5000);
+        await ctrl.onProgress('first');
+        await ctrl.onProgress('second'); // within throttle window
+        expect(message.edit).toHaveBeenCalledTimes(1);
+        expect(message.edits[0]).toBe('first');
+        ctrl.dispose();
+    });
+    it('onProgress with force: true bypasses the throttle', async () => {
+        const message = makeMessage();
+        const ctrl = createStreamingProgress(message, 5000);
+        await ctrl.onProgress('first');
+        await ctrl.onProgress('second', { force: true });
+        expect(message.edit).toHaveBeenCalledTimes(2);
+        expect(message.edits[1]).toBe('second');
+        ctrl.dispose();
+    });
+    it('onEvent feeds events into the queue and keepalive interval drives edits', async () => {
+        const message = makeMessage();
+        const ctrl = createStreamingProgress(message, 5000);
+        await ctrl.onProgress('Phase start', { force: true });
+        // Simulate a tool use event so the TAQ emits show_activity
+        ctrl.onEvent({ type: 'tool_start', name: 'Read', input: '' });
+        // Advance past STREAMING_EDIT_INTERVAL_MS (1250ms)
+        await vi.advanceTimersByTimeAsync(1300);
+        // The keepalive interval should have fired and edited with streaming content
+        expect(message.edit.mock.calls.length).toBeGreaterThan(1);
+        ctrl.dispose();
+    });
+    it('onProgress resets the queue so stale streaming state is cleared', async () => {
+        const message = makeMessage();
+        const ctrl = createStreamingProgress(message, 0);
+        // Feed some streaming state
+        ctrl.onEvent({ type: 'text_delta', text: 'stale text' });
+        // New phase boundary
+        await ctrl.onProgress('Phase 2 starting...', { force: true });
+        // Advance interval — should not show stale text since queue was reset
+        await vi.advanceTimersByTimeAsync(1300);
+        const lastEdit = message.edits[message.edits.length - 1];
+        // After reset, streaming state is cleared; last edit is the progress message
+        // or empty streaming output — not stale text
+        expect(lastEdit).not.toContain('stale text');
+        ctrl.dispose();
+    });
+    it('dispose clears the keepalive interval', async () => {
+        const message = makeMessage();
+        const ctrl = createStreamingProgress(message, 0);
+        const editsBefore = message.edit.mock.calls.length;
+        ctrl.dispose();
+        await vi.advanceTimersByTimeAsync(5000);
+        // No additional edits from the interval after dispose
+        expect(message.edit.mock.calls.length).toBe(editsBefore);
+    });
+    it('handles deleted-message (code 10008) gracefully — stops editing', async () => {
+        const message = makeMessage();
+        message.edit.mockRejectedValueOnce(Object.assign(new Error('Unknown Message'), { code: 10008 }));
+        const ctrl = createStreamingProgress(message, 0);
+        // First call triggers the 10008 error
+        await ctrl.onProgress('Starting...');
+        // Second call should be silently skipped (progressMessageGone = true)
+        await ctrl.onProgress('Next step...', { force: true });
+        expect(message.edit).toHaveBeenCalledTimes(1);
+        ctrl.dispose();
+    });
+});

package/dist/discord/summarizer.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+function safeSessionKey(sessionKey) {
+    return sessionKey.replace(/[^a-zA-Z0-9:_-]+/g, '-');
+}
+export async function loadSummary(dir, sessionKey) {
+    const filePath = path.join(dir, `${safeSessionKey(sessionKey)}.json`);
+    try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed &&
+            typeof parsed === 'object' &&
+            'summary' in parsed &&
+            typeof parsed.summary === 'string') {
+            return parsed;
+        }
+        return null;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT')
+            return null;
+        // Malformed file or other read error — treat as missing.
+        return null;
+    }
+}
+export async function saveSummary(dir, sessionKey, data) {
+    await fs.mkdir(dir, { recursive: true });
+    const filePath = path.join(dir, `${safeSessionKey(sessionKey)}.json`);
+    const tmp = `${filePath}.tmp.${process.pid}`;
+    await fs.writeFile(tmp, JSON.stringify(data, null, 2) + '\n', 'utf8');
+    await fs.rename(tmp, filePath);
+}
+const SUMMARIZE_PROMPT_TEMPLATE = `You are a conversation summarizer. Update the running summary below with the new exchange.
+
+Rules:
+- Keep the summary under {maxChars} characters.
+- Drop filler; keep decisions, preferences, current focus, and key facts.
+- Write in third person, present tense.
+- Output ONLY the updated summary text, nothing else.
+{taskStatusRule}
+{previousSection}
+{taskStatusSection}New exchange:
+{recentExchange}
+
+Updated summary:`;
+export async function generateSummary(runtime, opts) {
+    try {
+        const previousSection = opts.previousSummary
+            ? `Current summary:\n${opts.previousSummary}\n`
+            : 'Current summary:\n(none)\n';
+        const taskStatusRule = opts.taskStatusContext !== undefined
+            ? '- A task status snapshot is provided below. Update the summary to reflect the current status of any referenced tasks. Tasks listed under "Recently closed" are now done — correct any stale open references to them. Tasks not present as active and not listed as recently closed are likely closed — remove or correct stale open-task references. If the snapshot notes it is truncated, only reconcile tasks explicitly listed.'
+            : '';
+        const taskStatusSection = opts.taskStatusContext !== undefined
+            ? `Current task statuses:\n${opts.taskStatusContext}\n\n`
+            : '';
+        const prompt = SUMMARIZE_PROMPT_TEMPLATE
+            .replace('{maxChars}', String(opts.maxChars))
+            .replace('{taskStatusRule}', taskStatusRule)
+            .replace('{previousSection}', previousSection)
+            .replace('{taskStatusSection}', taskStatusSection)
+            .replace('{recentExchange}', opts.recentExchange);
+        let finalText = '';
+        let deltaText = '';
+        for await (const evt of runtime.invoke({
+            prompt,
+            model: opts.model,
+            cwd: opts.cwd,
+            tools: [],
+            timeoutMs: opts.timeoutMs,
+        })) {
+            if (evt.type === 'text_final') {
+                finalText = evt.text;
+            }
+            else if (evt.type === 'text_delta') {
+                deltaText += evt.text;
+            }
+            else if (evt.type === 'error') {
+                return opts.previousSummary ?? '';
+            }
+        }
+        const result = (finalText || deltaText).trim();
+        return result || (opts.previousSummary ?? '');
+    }
+    catch {
+        return opts.previousSummary ?? '';
+    }
+}