discoclaw 0.2.2 → 0.2.5

package/.context/pa.md

@@ -16,7 +16,6 @@ For architecture details, see `.context/architecture.md`.
 | `USER.md` | Who you're helping | Every prompt |
 | `AGENTS.md` | Your personal rules and conventions | Every prompt |
 | `TOOLS.md` | Available tools and integrations | Every prompt |
-| `HEARTBEAT.md` | Periodic self-check template | By cron |
 | `MEMORY.md` | Curated long-term memory | DM prompts |
 | `BOOTSTRAP.md` | First-run onboarding (deleted after) | Once |
 
@@ -27,6 +26,7 @@ Templates live in `templates/workspace/` and are scaffolded on first run (copy-i
 - **Never go silent.** Acknowledge before tool calls.
 - Narrate failures and pivots.
 - Summarize outcomes; don't assume the user saw tool output.
+- **Never edit `tasks.jsonl`, cron store files, or other data files directly.** Always use the corresponding discord action (`taskUpdate`, `taskCreate`, `cronUpdate`, etc.). Direct file edits bypass Discord thread sync and leave the UI stale.
 
 ## Discord Formatting
 

package/dist/cli/daemon-installer.js

@@ -68,6 +68,7 @@ export function renderSystemdUnit(packageRoot, cwd) {
         '',
         '[Service]',
         'Type=simple',
+        'Environment=PATH=%h/.local/bin:%h/.npm-global/bin:/usr/local/bin:/usr/bin:/bin',
         `ExecStart=/usr/bin/node ${entryPoint}`,
         `WorkingDirectory=${cwd}`,
         `EnvironmentFile=${path.join(cwd, '.env')}`,

package/dist/cli/daemon-installer.test.js

@@ -76,6 +76,12 @@ describe('renderSystemdUnit', () => {
         const unit = renderSystemdUnit(PACKAGE_ROOT, CWD);
         expect(unit).toContain(`EnvironmentFile=${CWD}/.env`);
     });
+    it('includes Environment=PATH with user-local bin directories', () => {
+        const unit = renderSystemdUnit(PACKAGE_ROOT, CWD);
+        expect(unit).toContain('Environment=PATH=');
+        expect(unit).toContain('%h/.local/bin');
+        expect(unit).toContain('%h/.npm-global/bin');
+    });
     it('includes standard unit and install sections', () => {
         const unit = renderSystemdUnit(PACKAGE_ROOT, CWD);
         expect(unit).toContain('[Unit]');

package/dist/cron/executor.js

@@ -124,6 +124,10 @@ export async function executeCronJob(job, ctx) {
         if (preRunRecord) {
             effectiveModel = preRunRecord.modelOverride ?? preRunRecord.model ?? cronDefault;
         }
+        // Silent mode: instruct the AI to respond with HEARTBEAT_OK when idle.
+        if (preRunRecord?.silent) {
+            prompt += '\n\nIMPORTANT: If there is nothing actionable to report, respond with exactly `HEARTBEAT_OK` and nothing else.';
+        }
         ctx.log?.info({ jobId: job.id, name: job.name, channel: job.def.channel, model: effectiveModel, permissionTier: tools.permissionTier }, 'cron:exec start');
         // Best-effort: update pinned status message to show running indicator.
         if (preRunRecord && job.cronId) {
@@ -269,13 +273,44 @@ export async function executeCronJob(job, ctx) {
         }
         processedText = appendUnavailableActionTypesNotice(processedText, strippedUnrecognizedTypes);
         processedText = appendParseFailureNotice(processedText, parseFailuresCount);
+        // Suppress sentinel outputs (e.g. crons whose prompts say "output nothing if idle").
+        // Mirrors the reaction handler's logic at reaction-handler.ts:662-674.
+        const strippedText = processedText.replace(/\s+/g, ' ').trim();
+        const isSuppressible = strippedText === 'HEARTBEAT_OK' || strippedText === '(no output)';
+        if (isSuppressible && collectedImages.length === 0) {
+            ctx.log?.info({ jobId: job.id, name: job.name, sentinel: strippedText }, 'cron:exec sentinel output suppressed');
+            if (ctx.statsStore && job.cronId) {
+                try {
+                    await ctx.statsStore.recordRun(job.cronId, 'success');
+                }
+                catch {
+                    // Best-effort.
+                }
+            }
+            metrics.increment('cron.run.success');
+            return;
+        }
+        // Silent-mode short-response gate: suppress paraphrased "nothing to report" responses.
+        if (preRunRecord?.silent && collectedImages.length === 0 && strippedText.length <= 80) {
+            ctx.log?.info({ jobId: job.id, name: job.name, len: strippedText.length }, 'cron:exec silent short-response suppressed');
+            if (ctx.statsStore && job.cronId) {
+                try {
+                    await ctx.statsStore.recordRun(job.cronId, 'success');
+                }
+                catch {
+                    // Best-effort.
+                }
+            }
+            metrics.increment('cron.run.success');
+            return;
+        }
         await sendChunks(channelForSend, processedText, collectedImages);
         ctx.log?.info({ jobId: job.id, name: job.name, channel: job.def.channel }, 'cron:exec done');
+        metrics.increment('cron.run.success');
         // Record successful run.
         if (ctx.statsStore && job.cronId) {
             try {
                 await ctx.statsStore.recordRun(job.cronId, 'success');
-                metrics.increment('cron.run.success');
             }
             catch (statsErr) {
                 ctx.log?.warn({ err: statsErr, jobId: job.id }, 'cron:exec stats record failed');

package/dist/cron/executor.test.js

@@ -324,6 +324,55 @@ describe('executeCronJob', () => {
         expect(subsArg).toMatchObject({ imagegenCtx });
         executeDiscordActionsSpy.mockRestore();
     });
+    it('suppresses HEARTBEAT_OK output', async () => {
+        const ctx = makeCtx({ runtime: makeMockRuntime('HEARTBEAT_OK') });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).not.toHaveBeenCalled();
+        expect(ctx.log?.info).toHaveBeenCalledWith(expect.objectContaining({ jobId: job.id, sentinel: 'HEARTBEAT_OK' }), 'cron:exec sentinel output suppressed');
+    });
+    it('suppresses (no output) output', async () => {
+        const ctx = makeCtx({ runtime: makeMockRuntime('(no output)') });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).not.toHaveBeenCalled();
+    });
+    it('does not suppress HEARTBEAT_OK when images are present', async () => {
+        const runtime = {
+            id: 'claude_code',
+            capabilities: new Set(['streaming_text']),
+            async *invoke() {
+                yield { type: 'text_final', text: 'HEARTBEAT_OK' };
+                yield { type: 'image_data', image: { mediaType: 'image/png', base64: 'abc123' } };
+                yield { type: 'done' };
+            },
+        };
+        const ctx = makeCtx({ runtime });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).toHaveBeenCalled();
+    });
+    it('records success in statsStore when sentinel is suppressed', async () => {
+        const statsStore = {
+            recordRun: vi.fn().mockResolvedValue(undefined),
+            recordRunStart: vi.fn().mockResolvedValue(undefined),
+            getRecord: vi.fn().mockReturnValue(undefined),
+            upsertRecord: vi.fn().mockResolvedValue(undefined),
+        };
+        const ctx = makeCtx({ runtime: makeMockRuntime('HEARTBEAT_OK'), statsStore });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        expect(statsStore.recordRun).toHaveBeenCalledWith('cron-test0001', 'success');
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).not.toHaveBeenCalled();
+    });
     it('does not post if output is empty', async () => {
         const ctx = makeCtx({ runtime: makeMockRuntime('') });
         const job = makeJob();
@@ -730,3 +779,111 @@ describe('executeCronJob write-ahead status tracking', () => {
         expect(rec?.lastRunStatus).toBe('success');
     });
 });
+// ---------------------------------------------------------------------------
+// Silent mode suppression
+// ---------------------------------------------------------------------------
+describe('executeCronJob silent mode', () => {
+    let statsDir;
+    beforeEach(async () => {
+        statsDir = await fs.mkdtemp(path.join(os.tmpdir(), 'executor-silent-'));
+    });
+    afterEach(async () => {
+        await fs.rm(statsDir, { recursive: true, force: true });
+    });
+    function makeCapturingRuntime(response) {
+        const invokeSpy = vi.fn();
+        return {
+            runtime: {
+                id: 'claude_code',
+                capabilities: new Set(['streaming_text']),
+                async *invoke(params) {
+                    invokeSpy(params);
+                    yield { type: 'text_final', text: response };
+                    yield { type: 'done' };
+                },
+            },
+            invokeSpy,
+        };
+    }
+    it('injects HEARTBEAT_OK instruction into the prompt when silent is true', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1', { silent: true });
+        const { runtime, invokeSpy } = makeCapturingRuntime('Hello!');
+        const ctx = makeCtx({ statsStore, runtime });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        expect(invokeSpy).toHaveBeenCalledOnce();
+        const prompt = invokeSpy.mock.calls[0][0].prompt;
+        expect(prompt).toContain('respond with exactly `HEARTBEAT_OK`');
+    });
+    it('suppresses short responses under the threshold when silent is true', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1', { silent: true });
+        const ctx = makeCtx({ statsStore, runtime: makeMockRuntime('No task-labeled emails found.') });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).not.toHaveBeenCalled();
+        expect(ctx.log?.info).toHaveBeenCalledWith(expect.objectContaining({ jobId: job.id, name: job.name }), 'cron:exec silent short-response suppressed');
+    });
+    it('does NOT suppress longer substantive responses when silent is true', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1', { silent: true });
+        const longResponse = 'Here is a detailed summary of the tasks completed today, including several important updates that need your attention.';
+        const ctx = makeCtx({ statsStore, runtime: makeMockRuntime(longResponse) });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).toHaveBeenCalledOnce();
+        expect(channel.send.mock.calls[0][0].content).toContain(longResponse);
+    });
+    it('does not apply short-response gate when silent is false', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1', { silent: false });
+        const ctx = makeCtx({ statsStore, runtime: makeMockRuntime('No emails found.') });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).toHaveBeenCalledOnce();
+    });
+    it('does NOT suppress short text when images are present (silent mode)', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1', { silent: true });
+        const runtime = {
+            id: 'claude_code',
+            capabilities: new Set(['streaming_text']),
+            async *invoke() {
+                yield { type: 'text_final', text: 'Short.' };
+                yield { type: 'image_data', image: { mediaType: 'image/png', base64: 'abc123' } };
+                yield { type: 'done' };
+            },
+        };
+        const ctx = makeCtx({ statsStore, runtime });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).toHaveBeenCalled();
+    });
+    it('records success in statsStore when silent short-response is suppressed', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1', { silent: true });
+        const recordRunSpy = vi.spyOn(statsStore, 'recordRun');
+        const ctx = makeCtx({ statsStore, runtime: makeMockRuntime('Nothing to report.') });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        expect(recordRunSpy).toHaveBeenCalledWith('cron-test0001', 'success');
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).not.toHaveBeenCalled();
+    });
+});

package/dist/cron/forum-sync.js

@@ -148,6 +148,12 @@ async function loadThreadAsCron(thread, guildId, scheduler, runtime, opts) {
                 cadence,
                 // Preserve existing disabled state.
                 disabled: existingRecord?.disabled ?? false,
+                // Persist parsed definition so future boots skip AI re-parsing.
+                schedule: def.schedule,
+                timezone: def.timezone,
+                channel: def.channel,
+                prompt: def.prompt,
+                authorId: starterAuthorId,
             });
             // Restore disabled state from stats.
             if (existingRecord?.disabled) {
@@ -207,6 +213,47 @@ export async function initCronForum(opts) {
     for (const thread of activeThreads.values()) {
         if (thread.archived)
             continue;
+        // Fast path: if the stats store already has a parsed definition for this
+        // thread, reconstruct the ParsedCronDef and register directly — skipping
+        // the AI parser entirely.  This avoids wasted AI calls on every boot and
+        // prevents parse-failure errors on threads whose starters aren't parseable
+        // (e.g. bot-formatted messages created by cronCreate).
+        if (statsStore) {
+            const record = statsStore.getRecordByThreadId(thread.id);
+            if (record && record.channel && record.prompt &&
+                (record.schedule || (record.triggerType !== undefined && record.triggerType !== 'schedule'))) {
+                // Authorization: verify stored author is still permitted.
+                const authorId = record.authorId ?? '';
+                const botUserId = client.user?.id ?? '';
+                const isBotAuthored = botUserId !== '' && authorId === botUserId;
+                if (!authorId || (!allowUserIds.has(authorId) && !isBotAuthored)) {
+                    // Author not authorized — fall through to loadThreadAsCron which
+                    // will reject and disable through its existing path.
+                }
+                else {
+                    const def = {
+                        triggerType: record.triggerType ?? 'schedule',
+                        schedule: record.schedule,
+                        timezone: record.timezone ?? 'UTC',
+                        channel: record.channel,
+                        prompt: record.prompt,
+                    };
+                    try {
+                        scheduler.register(thread.id, thread.id, guildId, thread.name, def, record.cronId);
+                        if (record.disabled) {
+                            scheduler.disable(thread.id);
+                            log?.info({ threadId: thread.id, cronId: record.cronId }, 'cron:forum fast-path restored disabled state');
+                        }
+                        loaded++;
+                        log?.info({ threadId: thread.id, cronId: record.cronId }, 'cron:forum fast-path loaded from stored definition');
+                        continue;
+                    }
+                    catch (err) {
+                        log?.warn({ err, threadId: thread.id, cronId: record.cronId }, 'cron:forum fast-path register failed, falling through to AI parse');
+                    }
+                }
+            }
+        }
         const ok = await loadThreadAsCron(thread, guildId, scheduler, runtime, { cronModel, cwd, log, isNew: false, allowUserIds, statsStore });
         if (ok)
             loaded++;

package/dist/cron/forum-sync.test.js

@@ -310,6 +310,240 @@ describe('initCronForum', () => {
         });
         expect(scheduler.register).toHaveBeenCalledWith('thread-1', 'thread-1', 'guild-1', 'Job 1', expect.objectContaining({ schedule: '0 7 * * *' }), 'cron-from-status-id');
     });
+    it('skips AI parse when stats store has stored definition (fast path)', async () => {
+        const thread = makeThread();
+        // fetchStarterMessage should NOT be called — fast path bypasses loadThreadAsCron entirely.
+        thread.fetchStarterMessage.mockResolvedValue(null);
+        const forum = makeForum([thread]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        scheduler.register.mockReturnValue({ cron: { nextRun: () => new Date() } });
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({
+                cronId: 'cron-stored',
+                threadId: 'thread-1',
+                disabled: false,
+                schedule: '0 7 * * *',
+                timezone: 'America/New_York',
+                channel: 'general',
+                prompt: 'Say good morning.',
+                authorId: 'u-allowed',
+                triggerType: 'schedule',
+            }),
+            getRecord: vi.fn(),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        await initCronForum({
+            client: client,
+            forumChannelNameOrId: 'forum-1',
+            allowUserIds: new Set(['u-allowed']),
+            scheduler: scheduler,
+            runtime: {},
+            cronModel: 'haiku',
+            cwd: '/tmp',
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+            statsStore: statsStore,
+        });
+        // AI parser should never be called.
+        expect(parseCronDefinition).not.toHaveBeenCalled();
+        // scheduler.register should receive the stored values.
+        expect(scheduler.register).toHaveBeenCalledWith('thread-1', 'thread-1', 'guild-1', 'Job 1', expect.objectContaining({
+            triggerType: 'schedule',
+            schedule: '0 7 * * *',
+            timezone: 'America/New_York',
+            channel: 'general',
+            prompt: 'Say good morning.',
+        }), 'cron-stored');
+        // fetchStarterMessage should not have been called (fast path skips loadThreadAsCron).
+        expect(thread.fetchStarterMessage).not.toHaveBeenCalled();
+    });
+    it('falls through to AI parse when stats store record lacks definition fields', async () => {
+        const thread = makeThread();
+        thread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: 'every day at 7am post to #general say hello',
+            author: { id: 'u-allowed' },
+            react: vi.fn().mockResolvedValue(undefined),
+        });
+        thread.messages.fetch = vi.fn().mockResolvedValue(new Map());
+        const forum = makeForum([thread]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        scheduler.register.mockReturnValue({ cron: { nextRun: () => new Date() } });
+        vi.mocked(parseCronDefinition).mockResolvedValue({
+            triggerType: 'schedule',
+            schedule: '0 7 * * *',
+            timezone: 'UTC',
+            channel: 'general',
+            prompt: 'Say hello.',
+        });
+        // Record exists but has no stored definition fields (pre-upgrade record).
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({
+                cronId: 'cron-old',
+                threadId: 'thread-1',
+                disabled: false,
+            }),
+            getRecord: vi.fn().mockReturnValue({
+                cronId: 'cron-old',
+                threadId: 'thread-1',
+                disabled: false,
+            }),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        await initCronForum({
+            client: client,
+            forumChannelNameOrId: 'forum-1',
+            allowUserIds: new Set(['u-allowed']),
+            scheduler: scheduler,
+            runtime: {},
+            cronModel: 'haiku',
+            cwd: '/tmp',
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+            statsStore: statsStore,
+        });
+        // Should fall through to AI parse since record lacks definition fields.
+        expect(parseCronDefinition).toHaveBeenCalled();
+    });
+    it('falls through to AI parse when fast-path register throws', async () => {
+        const thread = makeThread();
+        thread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: 'every day at 7am post to #general say hello',
+            author: { id: 'u-allowed' },
+            react: vi.fn().mockResolvedValue(undefined),
+        });
+        thread.messages.fetch = vi.fn().mockResolvedValue(new Map());
+        const forum = makeForum([thread]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        // First call (fast path) throws; second call (loadThreadAsCron fallback) succeeds.
+        scheduler.register
+            .mockImplementationOnce(() => { throw new Error('corrupt schedule'); })
+            .mockReturnValueOnce({ cron: { nextRun: () => new Date() } });
+        vi.mocked(parseCronDefinition).mockResolvedValue({
+            triggerType: 'schedule',
+            schedule: '0 7 * * *',
+            timezone: 'UTC',
+            channel: 'general',
+            prompt: 'Say hello.',
+        });
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({
+                cronId: 'cron-corrupt',
+                threadId: 'thread-1',
+                disabled: false,
+                schedule: 'BAD SCHEDULE',
+                timezone: 'UTC',
+                channel: 'general',
+                prompt: 'Say hello.',
+                authorId: 'u-allowed',
+            }),
+            getRecord: vi.fn().mockReturnValue({
+                cronId: 'cron-corrupt',
+                threadId: 'thread-1',
+                disabled: false,
+            }),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        await initCronForum({
+            client: client,
+            forumChannelNameOrId: 'forum-1',
+            allowUserIds: new Set(['u-allowed']),
+            scheduler: scheduler,
+            runtime: {},
+            cronModel: 'haiku',
+            cwd: '/tmp',
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+            statsStore: statsStore,
+        });
+        // Fast path failed, should fall through to AI parse.
+        expect(parseCronDefinition).toHaveBeenCalled();
+        // scheduler.register should have been called twice (fast path + fallback).
+        expect(scheduler.register).toHaveBeenCalledTimes(2);
+    });
+    it('disabled state restored via fast path', async () => {
+        const thread = makeThread();
+        thread.fetchStarterMessage.mockResolvedValue(null);
+        const forum = makeForum([thread]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        scheduler.register.mockReturnValue({ cron: { nextRun: () => new Date() } });
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({
+                cronId: 'cron-disabled-fp',
+                threadId: 'thread-1',
+                disabled: true,
+                schedule: '0 7 * * *',
+                timezone: 'UTC',
+                channel: 'general',
+                prompt: 'Say hello.',
+                authorId: 'u-allowed',
+            }),
+            getRecord: vi.fn(),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        await initCronForum({
+            client: client,
+            forumChannelNameOrId: 'forum-1',
+            allowUserIds: new Set(['u-allowed']),
+            scheduler: scheduler,
+            runtime: {},
+            cronModel: 'haiku',
+            cwd: '/tmp',
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+            statsStore: statsStore,
+        });
+        // Should register then immediately disable.
+        expect(scheduler.register).toHaveBeenCalledOnce();
+        expect(scheduler.disable).toHaveBeenCalledWith('thread-1');
+        // AI parser should NOT be called.
+        expect(parseCronDefinition).not.toHaveBeenCalled();
+    });
+    it('falls through when stored authorId is not in allowlist', async () => {
+        const thread = makeThread();
+        thread.fetchStarterMessage.mockResolvedValue({
+            id: 'm1',
+            content: 'every day at 7am post to #general say hello',
+            author: { id: 'u-not-allowed' },
+            react: vi.fn().mockResolvedValue(undefined),
+        });
+        thread.messages.fetch = vi.fn().mockResolvedValue(new Map());
+        const forum = makeForum([thread]);
+        const client = makeClient(forum);
+        const scheduler = makeScheduler();
+        const statsStore = {
+            getRecordByThreadId: vi.fn().mockReturnValue({
+                cronId: 'cron-unauth',
+                threadId: 'thread-1',
+                disabled: false,
+                schedule: '0 7 * * *',
+                timezone: 'UTC',
+                channel: 'general',
+                prompt: 'Say hello.',
+                authorId: 'u-not-allowed',
+            }),
+            getRecord: vi.fn(),
+            upsertRecord: vi.fn(async () => ({})),
+        };
+        await initCronForum({
+            client: client,
+            forumChannelNameOrId: 'forum-1',
+            allowUserIds: new Set(['u-allowed']),
+            scheduler: scheduler,
+            runtime: {},
+            cronModel: 'haiku',
+            cwd: '/tmp',
+            log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+            statsStore: statsStore,
+        });
+        // Should fall through to loadThreadAsCron which will reject and disable.
+        // fetchStarterMessage is called by loadThreadAsCron.
+        expect(thread.fetchStarterMessage).toHaveBeenCalled();
+        // scheduler.register should NOT be called (auth fails in loadThreadAsCron too).
+        expect(scheduler.register).not.toHaveBeenCalled();
+        expect(scheduler.disable).toHaveBeenCalledWith('thread-1');
+    });
     it('restores disabled state from stats store', async () => {
         const thread = makeThread();
         thread.fetchStarterMessage.mockResolvedValue({

package/dist/cron/run-stats.js

@@ -5,7 +5,7 @@ import crypto from 'node:crypto';
 // Types
 // ---------------------------------------------------------------------------
 export const CADENCE_TAGS = ['yearly', 'frequent', 'hourly', 'daily', 'weekly', 'monthly'];
-export const CURRENT_VERSION = 4;
+export const CURRENT_VERSION = 6;
 // ---------------------------------------------------------------------------
 // Stable Cron ID generation
 // ---------------------------------------------------------------------------
@@ -292,7 +292,14 @@ export async function loadRunStats(filePath) {
     if (store.version === 3) {
         store.version = 4;
     }
-    // Add future migration blocks here:
-    //   if (store.version === 4) { /* transform fields */; store.version = 5; }
+    // Migrate v4 → v5: no-op — new field (silent) is optional and defaults falsy.
+    if (store.version === 4) {
+        store.version = 5;
+    }
+    // Migrate v5 → v6: no-op — new persisted definition fields (schedule, timezone, channel, prompt, authorId) are optional.
+    // Absent records fall through to AI parsing on first boot after upgrade.
+    if (store.version === 5) {
+        store.version = 6;
+    }
     return new CronRunStats(store, filePath);
 }

package/dist/cron/run-stats.test.js

@@ -38,7 +38,7 @@ describe('CronRunStats', () => {
     it('creates empty store on missing file', async () => {
         const stats = await loadRunStats(statsPath);
         const store = stats.getStore();
-        expect(store.version).toBe(4);
+        expect(store.version).toBe(6);
         expect(Object.keys(store.jobs)).toHaveLength(0);
     });
     it('upserts and retrieves records by cronId', async () => {
@@ -210,7 +210,7 @@ describe('CronRunStats', () => {
 describe('emptyStore', () => {
     it('returns valid initial structure', () => {
         const store = emptyStore();
-        expect(store.version).toBe(4);
+        expect(store.version).toBe(6);
         expect(store.updatedAt).toBeGreaterThan(0);
         expect(Object.keys(store.jobs)).toHaveLength(0);
     });
@@ -237,7 +237,7 @@ describe('loadRunStats version migration', () => {
         };
         await fs.writeFile(statsPath, JSON.stringify(v3Store), 'utf-8');
         const stats = await loadRunStats(statsPath);
-        expect(stats.getStore().version).toBe(4);
+        expect(stats.getStore().version).toBe(6);
         const rec = stats.getRecord('cron-migrated');
         expect(rec).toBeDefined();
         expect(rec.cronId).toBe('cron-migrated');
@@ -246,4 +246,68 @@ describe('loadRunStats version migration', () => {
         expect(rec.cadence).toBe('daily');
         expect(rec.purposeTags).toEqual(['monitoring']);
     });
+    it('migrates a v4 store to v5 with silent undefined on existing records', async () => {
+        const v4Store = {
+            version: 4,
+            updatedAt: Date.now(),
+            jobs: {
+                'cron-v4': {
+                    cronId: 'cron-v4',
+                    threadId: 'thread-v4',
+                    runCount: 3,
+                    lastRunAt: '2025-06-01T00:00:00.000Z',
+                    lastRunStatus: 'success',
+                    cadence: 'hourly',
+                    purposeTags: ['email'],
+                    disabled: false,
+                    model: 'sonnet',
+                    triggerType: 'schedule',
+                },
+            },
+        };
+        await fs.writeFile(statsPath, JSON.stringify(v4Store), 'utf-8');
+        const stats = await loadRunStats(statsPath);
+        expect(stats.getStore().version).toBe(6);
+        const rec = stats.getRecord('cron-v4');
+        expect(rec).toBeDefined();
+        expect(rec.cronId).toBe('cron-v4');
+        expect(rec.runCount).toBe(3);
+        expect(rec.cadence).toBe('hourly');
+        expect(rec.silent).toBeUndefined();
+    });
+    it('migrates a v5 store to v6 with definition fields undefined on existing records', async () => {
+        const v5Store = {
+            version: 5,
+            updatedAt: Date.now(),
+            jobs: {
+                'cron-v5': {
+                    cronId: 'cron-v5',
+                    threadId: 'thread-v5',
+                    runCount: 7,
+                    lastRunAt: '2025-08-01T00:00:00.000Z',
+                    lastRunStatus: 'success',
+                    cadence: 'daily',
+                    purposeTags: ['greeting'],
+                    disabled: false,
+                    model: 'haiku',
+                    triggerType: 'schedule',
+                    silent: true,
+                },
+            },
+        };
+        await fs.writeFile(statsPath, JSON.stringify(v5Store), 'utf-8');
+        const stats = await loadRunStats(statsPath);
+        expect(stats.getStore().version).toBe(6);
+        const rec = stats.getRecord('cron-v5');
+        expect(rec).toBeDefined();
+        expect(rec.cronId).toBe('cron-v5');
+        expect(rec.runCount).toBe(7);
+        expect(rec.cadence).toBe('daily');
+        expect(rec.silent).toBe(true);
+        expect(rec.schedule).toBeUndefined();
+        expect(rec.timezone).toBeUndefined();
+        expect(rec.channel).toBeUndefined();
+        expect(rec.prompt).toBeUndefined();
+        expect(rec.authorId).toBeUndefined();
+    });
 });

package/dist/discord/actions-crons.js

@@ -147,6 +147,11 @@ export async function executeCronAction(action, ctx, cronCtx) {
                 cadence,
                 purposeTags,
                 model,
+                schedule: action.schedule,
+                timezone,
+                channel: action.channel,
+                prompt: action.prompt,
+                authorId: cronCtx.client.user?.id,
             });
             // Create status message.
             try {
@@ -214,7 +219,8 @@ export async function executeCronAction(action, ctx, cronCtx) {
                         }
                         else {
                             // Can't edit user's message — post update note.
-                            const note = `**Cron Updated**\n**Schedule:** \`${newSchedule}\` (${newTimezone})\n**Channel:** #${newChannel}\n\nPlease update the starter message to reflect these changes.`;
+                            const promptPreview = newPrompt.length > 200 ? `${newPrompt.slice(0, 200)}... (truncated)` : newPrompt;
+                            const note = `**Cron Updated**\n**Schedule:** \`${newSchedule}\` (${newTimezone})\n**Channel:** #${newChannel}\n**Prompt:** ${promptPreview}\n\nPlease update the starter message to reflect these changes.`;
                             await thread.send({ content: note, allowedMentions: { parse: [] } });
                         }
                     }
@@ -230,6 +236,11 @@ export async function executeCronAction(action, ctx, cronCtx) {
                     const msg = err instanceof Error ? err.message : String(err);
                     return { ok: false, error: `Invalid cron definition: ${msg}` };
                 }
+                // Persist updated definition fields.
+                updates.schedule = newSchedule;
+                updates.timezone = newTimezone;
+                updates.channel = newChannel;
+                updates.prompt = newPrompt;
             }
             await cronCtx.statsStore.upsertRecord(action.cronId, record.threadId, updates);
             // Update status message.
@@ -320,6 +331,11 @@ export async function executeCronAction(action, ctx, cronCtx) {
                 lines.push(`Tags: ${record.purposeTags.join(', ')}`);
             if (record.lastErrorMessage)
                 lines.push(`Last error: ${record.lastErrorMessage}`);
+            if (job) {
+                const promptText = job.def.prompt;
+                const truncated = promptText.length > 500 ? `${promptText.slice(0, 500)}... (truncated)` : promptText;
+                lines.push(`Prompt: ${truncated}`);
+            }
             return { ok: true, summary: lines.join('\n') };
         }
         case 'cronPause': {

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

@@ -484,6 +484,48 @@ describe('executeCronAction', () => {
             expect(result.summary).toContain('no sync coordinator configured');
         }
     });
+    it('cronShow includes Prompt line with job prompt text', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronShow', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('Prompt: Test');
+        }
+    });
+    it('cronShow truncates prompt longer than 500 chars', async () => {
+        const cronCtx = makeCronCtx();
+        const job = cronCtx.scheduler.getJob('thread-1');
+        job.def.prompt = 'x'.repeat(600);
+        const result = await executeCronAction({ type: 'cronShow', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).toContain('... (truncated)');
+            expect(result.summary).not.toContain('x'.repeat(600));
+        }
+    });
+    it('cronShow omits Prompt line when scheduler job is missing', async () => {
+        const cronCtx = makeCronCtx({ scheduler: makeScheduler([]) });
+        const result = await executeCronAction({ type: 'cronShow', cronId: 'cron-test0001' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.summary).not.toContain('Prompt:');
+        }
+    });
+    it('cronUpdate fallback note includes prompt when starter is not bot-owned', async () => {
+        const cronCtx = makeCronCtx();
+        const threadSend = vi.fn(async () => ({}));
+        const mockThread = {
+            id: 'thread-1',
+            isThread: () => true,
+            send: threadSend,
+            fetchStarterMessage: vi.fn(async () => ({ author: { id: 'other-user' }, edit: vi.fn() })),
+            setArchived: vi.fn(),
+        };
+        cronCtx.client.channels.cache.get.mockImplementation((id) => id === 'thread-1' ? mockThread : undefined);
+        const result = await executeCronAction({ type: 'cronUpdate', cronId: 'cron-test0001', prompt: 'New prompt text' }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(threadSend).toHaveBeenCalledWith(expect.objectContaining({ content: expect.stringContaining('New prompt text') }));
+    });
     it('cronTagMapReload failure returns error', async () => {
         const { reloadCronTagMapInPlace } = await import('../cron/tag-map.js');
         vi.mocked(reloadCronTagMapInPlace).mockRejectedValue(new Error('bad json'));

package/dist/discord/user-errors.js

@@ -43,6 +43,9 @@ export function mapRuntimeErrorToUserMessage(raw) {
         return ('This channel is missing required context. Create/index the channel context file under content/discord/channels ' +
             'or disable DISCORD_REQUIRE_CHANNEL_CONTEXT.');
     }
+    if (lc.includes('prompt is too long') || lc.includes('context length exceeded') || lc.includes('context_length_exceeded')) {
+        return 'The conversation context exceeded the model\'s limit. Try a shorter message or start a new conversation.';
+    }
     if (!msg) {
         return 'An unexpected runtime error occurred with no additional detail.';
     }

package/dist/discord/user-errors.test.js

@@ -36,4 +36,12 @@ describe('mapRuntimeErrorToUserMessage', () => {
         expect(msg).toContain('DISCOCLAW_STREAM_STALL_TIMEOUT_MS');
         expect(msg).not.toContain('ms /');
     });
+    it('maps "Prompt is too long" to context overflow user message', () => {
+        const msg = mapRuntimeErrorToUserMessage('Prompt is too long');
+        expect(msg).toBe('The conversation context exceeded the model\'s limit. Try a shorter message or start a new conversation.');
+    });
+    it('maps "context_length_exceeded" to context overflow user message', () => {
+        const msg = mapRuntimeErrorToUserMessage('context_length_exceeded');
+        expect(msg).toBe('The conversation context exceeded the model\'s limit. Try a shorter message or start a new conversation.');
+    });
 });

package/dist/runtime/cli-adapter.js

@@ -10,6 +10,16 @@ import { STDIN_THRESHOLD, tryParseJsonLine, createEventQueue, SubprocessTracker,
 import { extractTextFromUnknownEvent, extractResultText, extractImageFromUnknownEvent, extractResultContentBlocks, imageDedupeKey, stripToolUseBlocks, } from './cli-output-parsers.js';
 // Global subprocess tracker shared across all CLI adapters.
 const globalTracker = new SubprocessTracker();
+const CONTEXT_OVERFLOW_PHRASES = [
+    'prompt is too long',
+    'context length exceeded',
+    'context_length_exceeded',
+    'context overflow',
+];
+function isContextOverflowMessage(text) {
+    const lower = text.toLowerCase();
+    return CONTEXT_OVERFLOW_PHRASES.some((phrase) => lower.includes(phrase));
+}
 function asCliLogLike(log) {
     if (!log || typeof log !== 'object')
         return undefined;
@@ -95,10 +105,19 @@ export function createCliRuntime(strategy, opts) {
                     const onPoolAbort = () => { proc.kill?.(); };
                     params.signal?.addEventListener('abort', onPoolAbort, { once: true });
                     let fallback = false;
+                    let contextOverflow = false;
                     try {
                         for await (const evt of proc.sendTurn(params.prompt, params.images)) {
                             if (evt.type === 'error' && (evt.message.startsWith('long-running:') || evt.message.includes('hang detected'))) {
-                                pool.remove(params.sessionKey);
+                                if (evt.message.includes('context overflow'))
+                                    contextOverflow = true;
+                                pool.remove(params.sessionKey, contextOverflow ? 'context-overflow' : undefined);
+                                fallback = true;
+                                break;
+                            }
+                            if ((evt.type === 'text_delta' || evt.type === 'text_final') && isContextOverflowMessage(evt.text)) {
+                                pool.remove(params.sessionKey, 'context-overflow');
+                                contextOverflow = true;
                                 fallback = true;
                                 break;
                             }
@@ -112,6 +131,10 @@ export function createCliRuntime(strategy, opts) {
                         globalTracker.delete(sub);
                     if (!fallback)
                         return;
+                    if (contextOverflow) {
+                        cliLog?.info?.({ sessionKey: params.sessionKey }, 'multi-turn: context overflow, resetting session and retrying');
+                        yield { type: 'text_delta', text: '*(Session reset — conversation context limit reached. Starting fresh.)*\n\n' };
+                    }
                     cliLog?.info?.('multi-turn: process failed, falling back to one-shot');
                 }
             }

package/dist/runtime/long-running-process.js

@@ -288,11 +288,23 @@ export class LongRunningProcess {
             }
         }
     }
+    isContextOverflow(text) {
+        const lower = text.toLowerCase();
+        return (lower.includes('prompt is too long') ||
+            lower.includes('context length exceeded') ||
+            lower.includes('context_length_exceeded'));
+    }
     finalizeTurn() {
         const raw = this.turnResultText.trim() || (this.turnMerged.trim() ? this.turnMerged.trimEnd() : '');
         const final = stripToolUseBlocks(raw);
-        if (final)
-            this.pushEvent({ type: 'text_final', text: final });
+        if (final) {
+            if (this.isContextOverflow(final)) {
+                this.pushEvent({ type: 'error', message: 'long-running: context overflow' });
+            }
+            else {
+                this.pushEvent({ type: 'text_final', text: final });
+            }
+        }
         this.pushDoneOnce();
     }
     handleExit() {

package/dist/runtime/long-running-process.test.js

@@ -299,6 +299,23 @@ describe('LongRunningProcess', () => {
         expect(callArgs).not.toContain('--max-budget-usd');
         expect(callArgs).not.toContain('--append-system-prompt');
     });
+    it('context overflow result emits error event instead of text_final', async () => {
+        const mock = createMockSubprocess();
+        execa.mockReturnValue(mock.proc);
+        const proc = new LongRunningProcess(baseOpts);
+        proc.spawn();
+        queueMicrotask(() => {
+            mock.stdout.emit('data', JSON.stringify({ type: 'result', result: 'Prompt is too long' }) + '\n');
+        });
+        const events = [];
+        for await (const evt of proc.sendTurn('tell me everything')) {
+            events.push(evt);
+        }
+        expect(events.find((e) => e.type === 'error')?.message).toBe('long-running: context overflow');
+        expect(events.find((e) => e.type === 'done')).toBeTruthy();
+        expect(events.find((e) => e.type === 'text_final')).toBeUndefined();
+        expect(proc.state).toBe('idle');
+    });
     it('sendTurn without images writes plain string content (no regression)', async () => {
         const mock = createMockSubprocess();
         execa.mockReturnValue(mock.proc);

package/dist/runtime/process-pool.js

@@ -59,12 +59,12 @@ export class ProcessPool {
         return proc;
     }
     /** Kill and remove a specific session's process. */
-    remove(sessionKey) {
+    remove(sessionKey, reason) {
         const proc = this.pool.get(sessionKey);
         if (proc) {
             this.pool.delete(sessionKey);
             proc.kill();
-            this.log?.info({ sessionKey }, 'process-pool: removed process');
+            this.log?.info({ sessionKey, reason }, 'process-pool: removed process');
         }
     }
     /** Kill all processes (shutdown cleanup). */

package/dist/workspace-bootstrap.js

@@ -11,7 +11,6 @@ const TEMPLATE_FILES = [
     'USER.md',
     'AGENTS.md',
     'TOOLS.md',
-    'HEARTBEAT.md',
     'MEMORY.md',
 ];
 /** Marker text present in the template IDENTITY.md but removed during onboarding. */

package/dist/workspace-bootstrap.test.js

@@ -16,7 +16,6 @@ const ALL_TEMPLATE_FILES = [
     'USER.md',
     'AGENTS.md',
     'TOOLS.md',
-    'HEARTBEAT.md',
     'MEMORY.md',
 ];
 /** Real IDENTITY.md content that passes onboarding check (no template marker). */
@@ -199,7 +198,6 @@ describe('ensureWorkspaceBootstrapFiles', () => {
             'SOUL.md': 'My soul',
             'TOOLS.md': 'My tools',
             'USER.md': 'My user',
-            'HEARTBEAT.md': 'My heartbeat',
             'MEMORY.md': 'My memory',
         };
         for (const [file, content] of Object.entries(customFiles)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discoclaw",
-  "version": "0.2.2",
+  "version": "0.2.5",
   "description": "Minimal Discord bridge routing messages to AI runtimes",
   "license": "MIT",
   "repository": {

package/systemd/discoclaw.service

@@ -5,6 +5,7 @@ Wants=network-online.target
 
 [Service]
 Type=simple
+Environment=PATH=%h/.local/bin:%h/.npm-global/bin:/usr/local/bin:/usr/bin:/bin
 WorkingDirectory=%h/code/discoclaw
 # Keep secrets local; this file should exist on the host (not committed).
 EnvironmentFile=%h/code/discoclaw/.env

package/templates/workspace/HEARTBEAT.md

@@ -1,10 +0,0 @@
-# HEARTBEAT.md
-
-# Keep this file empty (or with only comments) to skip heartbeat tasks.
-
-# Add tasks below when you want the agent to check something periodically.
-
-# --- Memory maintenance (uncomment to enable) ---
-# - Review daily logs older than 7 days in memory/. Distill anything worth keeping into MEMORY.md, then delete the old daily file.
-# - Check MEMORY.md for stale or superseded entries. Remove anything no longer relevant.
-# - If MEMORY.md exceeds ~2 KB, prune aggressively — keep only what matters for future sessions.