discoclaw 0.2.2 → 0.2.4

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/discord/actions-crons.js

@@ -214,7 +214,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: [] } });
                         }
                     }
@@ -320,6 +321,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discoclaw",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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