discoclaw 0.2.1 → 0.2.4

package/.env.example.full

@@ -318,6 +318,9 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 # managers, or running under a different user). If unset, the command is
 # auto-selected: systemctl --user on Linux, launchctl on macOS.
 #DC_RESTART_CMD=
+# Sets the systemd unit / launchd label name used by !restart and !update apply.
+# Default: discoclaw. Ignored when DC_RESTART_CMD is set (that overrides the entire command).
+#DISCOCLAW_SERVICE_NAME=discoclaw
 # Global cap on parallel runtime invocations across all Discord sessions (0 = unlimited).
 #DISCOCLAW_MAX_CONCURRENT_INVOCATIONS=3
 # Max depth for chained action follow-ups (e.g. defer → action → response). 0 = disabled.

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')}`,
@@ -119,8 +120,38 @@ export function renderLaunchdPlist(packageRoot, cwd, envVars, serviceName = 'dis
     lines.push('');
     return lines.join('\n');
 }
+// ── Env helpers ────────────────────────────────────────────────────────────
+/**
+ * Ensures DISCOCLAW_SERVICE_NAME in the .env file reflects serviceName.
+ * - Default ('discoclaw'): removes any existing DISCOCLAW_SERVICE_NAME line.
+ * - Non-default: replaces existing line in-place, or appends a new one.
+ * Only writes if content actually changed.
+ */
+export function ensureServiceNameInEnv(envPath, serviceName) {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const KEY = 'DISCOCLAW_SERVICE_NAME';
+    const lineRegex = /^DISCOCLAW_SERVICE_NAME=.*$/m;
+    let newContent;
+    if (serviceName === 'discoclaw') {
+        if (!lineRegex.test(content))
+            return;
+        newContent = content.replace(/^DISCOCLAW_SERVICE_NAME=.*\n?/m, '');
+    }
+    else {
+        if (lineRegex.test(content)) {
+            newContent = content.replace(lineRegex, `${KEY}=${serviceName}`);
+        }
+        else {
+            const sep = content.endsWith('\n') ? '' : '\n';
+            newContent = `${content}${sep}${KEY}=${serviceName}\n`;
+        }
+    }
+    if (newContent !== content) {
+        fs.writeFileSync(envPath, newContent, 'utf8');
+    }
+}
 // ── Platform installers ────────────────────────────────────────────────────
-async function installSystemd(packageRoot, cwd, serviceName, ask) {
+async function installSystemd(packageRoot, cwd, envPath, serviceName, ask) {
     const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
     const servicePath = path.join(serviceDir, `${serviceName}.service`);
     if (fs.existsSync(servicePath)) {
@@ -130,6 +161,13 @@ async function installSystemd(packageRoot, cwd, serviceName, ask) {
             return;
         }
     }
+    try {
+        ensureServiceNameInEnv(envPath, serviceName);
+    }
+    catch (err) {
+        console.error(`Failed to update .env: ${err.message}\n`);
+        process.exit(1);
+    }
     const unit = renderSystemdUnit(packageRoot, cwd);
     fs.mkdirSync(serviceDir, { recursive: true });
     fs.writeFileSync(servicePath, unit, 'utf8');
@@ -168,6 +206,13 @@ async function installLaunchd(packageRoot, cwd, envPath, serviceName, ask) {
             return;
         }
     }
+    try {
+        ensureServiceNameInEnv(envPath, serviceName);
+    }
+    catch (err) {
+        console.error(`Failed to update .env: ${err.message}\n`);
+        process.exit(1);
+    }
     const envContent = fs.readFileSync(envPath, 'utf8');
     const envVars = parseEnvFile(envContent);
     const plist = renderLaunchdPlist(packageRoot, cwd, envVars, serviceName);
@@ -229,7 +274,7 @@ export async function runDaemonInstaller() {
     const ask = (prompt) => rl.question(prompt);
     try {
         if (platform === 'linux') {
-            await installSystemd(packageRoot, cwd, serviceName, ask);
+            await installSystemd(packageRoot, cwd, envPath, serviceName, ask);
         }
         else {
             await installLaunchd(packageRoot, cwd, envPath, serviceName, ask);

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

@@ -16,7 +16,7 @@ vi.mock('node:readline/promises', () => ({
 import fs from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { createInterface } from 'node:readline/promises';
-import { parseEnvFile, parseServiceName, renderSystemdUnit, renderLaunchdPlist, runDaemonInstaller, } from './daemon-installer.js';
+import { ensureServiceNameInEnv, parseEnvFile, parseServiceName, renderSystemdUnit, renderLaunchdPlist, runDaemonInstaller, } from './daemon-installer.js';
 // ── Test helpers ───────────────────────────────────────────────────────────
 function makeReadline(answers = []) {
     return {
@@ -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]');
@@ -121,6 +127,43 @@ describe('renderLaunchdPlist', () => {
         expect(plist).toContain('<true/>');
     });
 });
+// ── ensureServiceNameInEnv ─────────────────────────────────────────────────
+describe('ensureServiceNameInEnv', () => {
+    const ENV_PATH = '/home/user/bot/.env';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(fs.writeFileSync).mockReturnValue(undefined);
+    });
+    it('default name, no existing line — content is unchanged', () => {
+        vi.mocked(fs.readFileSync).mockReturnValue('DISCORD_TOKEN=abc\n');
+        ensureServiceNameInEnv(ENV_PATH, 'discoclaw');
+        expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+    it('custom name, no existing line — appends DISCOCLAW_SERVICE_NAME=custom-name', () => {
+        vi.mocked(fs.readFileSync).mockReturnValue('DISCORD_TOKEN=abc\n');
+        ensureServiceNameInEnv(ENV_PATH, 'custom-name');
+        expect(fs.writeFileSync).toHaveBeenCalledWith(ENV_PATH, 'DISCORD_TOKEN=abc\nDISCOCLAW_SERVICE_NAME=custom-name\n', 'utf8');
+    });
+    it('custom name, existing stale line — replaces old value in-place, no duplicate', () => {
+        vi.mocked(fs.readFileSync).mockReturnValue('DISCORD_TOKEN=abc\nDISCOCLAW_SERVICE_NAME=old-name\nFOO=bar\n');
+        ensureServiceNameInEnv(ENV_PATH, 'new-name');
+        const written = vi.mocked(fs.writeFileSync).mock.calls[0][1];
+        expect(written).toContain('DISCOCLAW_SERVICE_NAME=new-name');
+        expect(written).not.toContain('DISCOCLAW_SERVICE_NAME=old-name');
+        expect((written.match(/DISCOCLAW_SERVICE_NAME=/g) ?? []).length).toBe(1);
+    });
+    it('default name, existing stale line — removes DISCOCLAW_SERVICE_NAME line', () => {
+        vi.mocked(fs.readFileSync).mockReturnValue('DISCORD_TOKEN=abc\nDISCOCLAW_SERVICE_NAME=old-name\n');
+        ensureServiceNameInEnv(ENV_PATH, 'discoclaw');
+        const written = vi.mocked(fs.writeFileSync).mock.calls[0][1];
+        expect(written).not.toContain('DISCOCLAW_SERVICE_NAME');
+    });
+    it('custom name matches existing line — no file write (no-op)', () => {
+        vi.mocked(fs.readFileSync).mockReturnValue('DISCORD_TOKEN=abc\nDISCOCLAW_SERVICE_NAME=custom-name\n');
+        ensureServiceNameInEnv(ENV_PATH, 'custom-name');
+        expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+});
 // ── runDaemonInstaller ─────────────────────────────────────────────────────
 const originalIsTTY = process.stdin.isTTY;
 const originalPlatform = process.platform;
@@ -306,4 +349,49 @@ describe('runDaemonInstaller', () => {
         expect(fs.writeFileSync).not.toHaveBeenCalled();
         expect(execFileSync).not.toHaveBeenCalled();
     });
+    it('linux: does not mutate .env when overwrite is declined with custom --service-name', async () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        const originalArgv = process.argv;
+        process.argv = ['node', 'discoclaw', 'install-daemon', '--service-name', 'custom'];
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+            const s = String(p);
+            if (s.endsWith('.env'))
+                return true;
+            if (s.endsWith('dist/index.js'))
+                return true;
+            if (s.endsWith('custom.service'))
+                return true;
+            return false;
+        });
+        const rl = makeReadline(['n']); // decline overwrite
+        vi.mocked(createInterface).mockReturnValue(rl);
+        try {
+            await runDaemonInstaller();
+        }
+        finally {
+            process.argv = originalArgv;
+        }
+        expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+    it('linux: writes DISCOCLAW_SERVICE_NAME=custom to .env before service file when --service-name custom is passed', async () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        const originalArgv = process.argv;
+        process.argv = ['node', 'discoclaw', 'install-daemon', '--service-name', 'custom'];
+        // .env has no DISCOCLAW_SERVICE_NAME yet
+        vi.mocked(fs.readFileSync).mockReturnValue(SAMPLE_ENV);
+        try {
+            await runDaemonInstaller();
+        }
+        finally {
+            process.argv = originalArgv;
+        }
+        const calls = vi.mocked(fs.writeFileSync).mock.calls;
+        const envWriteIdx = calls.findIndex(([p]) => String(p).endsWith('.env'));
+        const serviceWriteIdx = calls.findIndex(([p]) => String(p).endsWith('custom.service'));
+        expect(envWriteIdx).toBeGreaterThanOrEqual(0);
+        expect(calls[envWriteIdx][1]).toContain('DISCOCLAW_SERVICE_NAME=custom');
+        expect(serviceWriteIdx).toBeGreaterThan(envWriteIdx);
+    });
 });

package/dist/config.js

@@ -406,6 +406,7 @@ export function parseConfig(env) {
             botActivity: parseTrimmedString(env, 'DISCOCLAW_BOT_ACTIVITY'),
             botActivityType: parseEnum(env, 'DISCOCLAW_BOT_ACTIVITY_TYPE', ['Playing', 'Listening', 'Watching', 'Competing', 'Custom'], 'Playing'),
             botAvatar: parseAvatarPath(env, 'DISCOCLAW_BOT_AVATAR'),
+            serviceName: parseTrimmedString(env, 'DISCOCLAW_SERVICE_NAME') ?? 'discoclaw',
         },
         warnings,
         infos,

package/dist/config.test.js

@@ -27,6 +27,7 @@ describe('parseConfig', () => {
         expect(config.tasksSyncFailureRetryDelayMs).toBe(30_000);
         expect(config.tasksSyncDeferredRetryDelayMs).toBe(30_000);
         expect(config.outputFormat).toBe('text');
+        expect(config.serviceName).toBe('discoclaw');
         expect(warnings.some((w) => w.includes('category flags are ignored'))).toBe(false);
         expect(infos.some((i) => i.includes('category flags are ignored'))).toBe(false);
     });
@@ -693,4 +694,17 @@ describe('parseConfig', () => {
         const { config } = parseConfig(env({ DISCOCLAW_WEBHOOK_CONFIG: '/etc/discoclaw/webhooks.json' }));
         expect(config.webhookConfigPath).toBe('/etc/discoclaw/webhooks.json');
     });
+    // --- serviceName ---
+    it('defaults serviceName to "discoclaw"', () => {
+        const { config } = parseConfig(env());
+        expect(config.serviceName).toBe('discoclaw');
+    });
+    it('parses DISCOCLAW_SERVICE_NAME when set', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_SERVICE_NAME: 'discoclaw-dev' }));
+        expect(config.serviceName).toBe('discoclaw-dev');
+    });
+    it('returns default serviceName when DISCOCLAW_SERVICE_NAME is whitespace-only', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_SERVICE_NAME: '   ' }));
+        expect(config.serviceName).toBe('discoclaw');
+    });
 });

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/message-coordinator.js

@@ -494,6 +494,7 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                     dataDir: params.dataDir,
                     userId: msg.author.id,
                     activeForge: getActiveOrchestrator()?.activePlanId,
+                    serviceName: params.serviceName,
                 });
                 await msg.reply({ content: result.reply, allowedMentions: NO_MENTIONS });
                 // Deferred action (e.g., restart) runs after the reply is sent.
@@ -509,6 +510,7 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                     projectCwd: params.projectCwd,
                     dataDir: params.dataDir,
                     restartCmd: params.updateRestartCmd,
+                    serviceName: params.serviceName,
                 });
                 await msg.reply({ content: result.reply, allowedMentions: NO_MENTIONS });
                 // Deferred action (e.g., restart after apply) runs after the reply is sent.

package/dist/discord/restart-command.js

@@ -30,21 +30,21 @@ function mapExitCode(err) {
         return 0;
     return typeof err.code === 'number' ? err.code : null;
 }
-function getPlatformCommands() {
+function getPlatformCommands(serviceName = 'discoclaw') {
     if (process.platform === 'linux') {
         return {
-            statusCmd: ['systemctl', ['--user', 'status', 'discoclaw']],
-            logsCmd: ['journalctl', ['--user', '-u', 'discoclaw', '--no-pager', '-n', '30']],
-            checkActiveCmd: ['systemctl', ['--user', 'status', 'discoclaw']],
+            statusCmd: ['systemctl', ['--user', 'status', serviceName]],
+            logsCmd: ['journalctl', ['--user', '-u', serviceName, '--no-pager', '-n', '30']],
+            checkActiveCmd: ['systemctl', ['--user', 'status', serviceName]],
             isActive: (result) => result.stdout.includes('active (running)'),
-            restartCmd: () => ['systemctl', ['--user', 'restart', 'discoclaw']],
+            restartCmd: () => ['systemctl', ['--user', 'restart', serviceName]],
         };
     }
     if (process.platform === 'darwin') {
         const uid = process.getuid?.() ?? 501;
-        const plistPath = `${os.homedir()}/Library/LaunchAgents/com.discoclaw.agent.plist`;
+        const label = `com.discoclaw.${serviceName}`;
+        const plistPath = `${os.homedir()}/Library/LaunchAgents/${label}.plist`;
         const domain = `gui/${uid}`;
-        const label = 'com.discoclaw.agent';
         return {
             statusCmd: ['launchctl', ['list', label]],
             logsCmd: ['log', ['show', '--predicate', 'process == "node"', '--last', '5m', '--style', 'compact']],
@@ -62,18 +62,18 @@ function getPlatformCommands() {
  * platform, assuming the service is already running. Falls back to systemctl
  * on unsupported platforms.
  */
-export function getRestartCmdArgs() {
-    const pc = getPlatformCommands();
+export function getRestartCmdArgs(serviceName) {
+    const pc = getPlatformCommands(serviceName);
     if (pc)
         return pc.restartCmd(true);
-    return ['systemctl', ['--user', 'restart', 'discoclaw']];
+    return ['systemctl', ['--user', 'restart', serviceName ?? 'discoclaw']];
 }
 export async function handleRestartCommand(cmd, opts) {
     // Support both legacy (log) and new (opts bag) signatures.
     const resolved = opts && typeof opts === 'object' && 'info' in opts
         ? { log: opts }
         : opts ?? {};
-    const { log, dataDir, userId, activeForge } = resolved;
+    const { log, dataDir, userId, activeForge, serviceName = 'discoclaw' } = resolved;
     try {
         if (cmd.action === 'help') {
             return {
@@ -86,7 +86,7 @@ export async function handleRestartCommand(cmd, opts) {
                 ].join('\n'),
             };
         }
-        const pc = getPlatformCommands();
+        const pc = getPlatformCommands(serviceName);
         if (!pc) {
             return {
                 reply: `!restart is not supported on this platform (${process.platform}). Only Linux (systemd) and macOS (launchd) are supported.`,
@@ -114,8 +114,8 @@ export async function handleRestartCommand(cmd, opts) {
         // invokes *after* sending the reply to Discord.
         return {
             reply: wasActive
-                ? 'Restarting discoclaw... back in a moment.'
-                : 'Starting discoclaw...',
+                ? `Restarting ${serviceName}... back in a moment.`
+                : `Starting ${serviceName}...`,
             deferred: () => {
                 // Write shutdown context right before triggering restart so it
                 // doesn't linger if the deferred never fires or restart fails.

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

@@ -126,7 +126,7 @@ describe('handleRestartCommand - macOS', () => {
         const statusCall = calls.find((c) => c[0] === 'launchctl');
         expect(statusCall).toBeDefined();
         expect(statusCall[1]).toContain('list');
-        expect(statusCall[1]).toContain('com.discoclaw.agent');
+        expect(statusCall[1]).toContain('com.discoclaw.discoclaw');
         // Must NOT call systemctl
         expect(calls.every((c) => c[0] !== 'systemctl')).toBe(true);
     });
@@ -154,7 +154,7 @@ describe('handleRestartCommand - macOS', () => {
         const kickstartCall = calls.find((c) => c[0] === 'launchctl' && c[1].includes('kickstart'));
         expect(kickstartCall).toBeDefined();
         expect(kickstartCall[1]).toContain('-k');
-        expect(kickstartCall[1]).toContain('gui/501/com.discoclaw.agent');
+        expect(kickstartCall[1]).toContain('gui/501/com.discoclaw.discoclaw');
     });
     it('restart uses launchctl bootstrap in deferred when service is inactive', async () => {
         const { execFile } = await import('node:child_process');
@@ -171,7 +171,96 @@ describe('handleRestartCommand - macOS', () => {
         const bootstrapCall = calls.find((c) => c[0] === 'launchctl' && c[1].includes('bootstrap'));
         expect(bootstrapCall).toBeDefined();
         expect(bootstrapCall[1]).toContain('gui/501');
-        expect(bootstrapCall[1]).toContain('/Users/testuser/Library/LaunchAgents/com.discoclaw.agent.plist');
+        expect(bootstrapCall[1]).toContain('/Users/testuser/Library/LaunchAgents/com.discoclaw.discoclaw.plist');
+    });
+});
+describe('handleRestartCommand - custom serviceName (Linux)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+    });
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: savedPlatform, configurable: true });
+    });
+    it('default serviceName still targets discoclaw in systemctl args', async () => {
+        const { execFile } = await import('node:child_process');
+        await handleRestartCommand({ action: 'status' });
+        const calls = execFile.mock.calls;
+        const statusCall = calls.find((c) => c[0] === 'systemctl');
+        expect(statusCall[1]).toContain('discoclaw');
+    });
+    it('default restart reply still says "Restarting discoclaw..."', async () => {
+        const result = await handleRestartCommand({ action: 'restart' });
+        expect(result.reply).toBe('Restarting discoclaw... back in a moment.');
+    });
+    it('custom serviceName threads into systemctl status args', async () => {
+        const { execFile } = await import('node:child_process');
+        await handleRestartCommand({ action: 'status' }, { serviceName: 'discoclaw-beta' });
+        const calls = execFile.mock.calls;
+        const statusCall = calls.find((c) => c[0] === 'systemctl' && c[1].includes('status'));
+        expect(statusCall[1]).toContain('discoclaw-beta');
+        expect(statusCall[1]).not.toContain('discoclaw-beta'.replace('discoclaw-beta', 'discoclaw'));
+    });
+    it('custom serviceName threads into journalctl logs args', async () => {
+        const { execFile } = await import('node:child_process');
+        await handleRestartCommand({ action: 'logs' }, { serviceName: 'discoclaw-beta' });
+        const calls = execFile.mock.calls;
+        const logsCall = calls.find((c) => c[0] === 'journalctl');
+        expect(logsCall).toBeDefined();
+        expect(logsCall[1]).toContain('discoclaw-beta');
+    });
+    it('custom serviceName threads into systemctl restart args and reply string', async () => {
+        const { execFile } = await import('node:child_process');
+        const result = await handleRestartCommand({ action: 'restart' }, { serviceName: 'discoclaw-beta' });
+        expect(result.reply).toBe('Restarting discoclaw-beta... back in a moment.');
+        result.deferred();
+        const calls = execFile.mock.calls;
+        const restartCall = calls.find((c) => c[0] === 'systemctl' && c[1].includes('restart'));
+        expect(restartCall).toBeDefined();
+        expect(restartCall[1]).toContain('discoclaw-beta');
+    });
+});
+describe('handleRestartCommand - custom serviceName (macOS)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+        vi.spyOn(process, 'getuid').mockReturnValue(501);
+    });
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: savedPlatform, configurable: true });
+        vi.restoreAllMocks();
+    });
+    it('custom serviceName threads into launchctl label and plist path', async () => {
+        const { execFile } = await import('node:child_process');
+        const result = await handleRestartCommand({ action: 'restart' }, { serviceName: 'discoclaw-beta' });
+        expect(result.reply).toBe('Restarting discoclaw-beta... back in a moment.');
+        result.deferred();
+        const calls = execFile.mock.calls;
+        const kickstartCall = calls.find((c) => c[0] === 'launchctl' && c[1].includes('kickstart'));
+        expect(kickstartCall).toBeDefined();
+        expect(kickstartCall[1]).toContain('gui/501/com.discoclaw.discoclaw-beta');
+    });
+    it('custom serviceName uses correct plist path on bootstrap', async () => {
+        const { execFile } = await import('node:child_process');
+        execFile.mockImplementationOnce((cmd, args, opts, cb) => {
+            const err = Object.assign(new Error('not loaded'), { code: 1 });
+            cb(err, '', '');
+        });
+        const result = await handleRestartCommand({ action: 'restart' }, { serviceName: 'discoclaw-beta' });
+        expect(result.reply).toBe('Starting discoclaw-beta...');
+        result.deferred();
+        const calls = execFile.mock.calls;
+        const bootstrapCall = calls.find((c) => c[0] === 'launchctl' && c[1].includes('bootstrap'));
+        expect(bootstrapCall).toBeDefined();
+        expect(bootstrapCall[1]).toContain('/Users/testuser/Library/LaunchAgents/com.discoclaw.discoclaw-beta.plist');
+    });
+    it('custom serviceName threads into launchctl list (status)', async () => {
+        const { execFile } = await import('node:child_process');
+        await handleRestartCommand({ action: 'status' }, { serviceName: 'discoclaw-beta' });
+        const calls = execFile.mock.calls;
+        const listCall = calls.find((c) => c[0] === 'launchctl' && c[1].includes('list'));
+        expect(listCall).toBeDefined();
+        expect(listCall[1]).toContain('com.discoclaw.discoclaw-beta');
     });
 });
 describe('handleRestartCommand - unsupported platform', () => {

package/dist/discord/update-command.js

@@ -35,7 +35,7 @@ function mapExitCode(err) {
 }
 const GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: '0' };
 export async function handleUpdateCommand(cmd, opts = {}) {
-    const { log, dataDir, userId, restartCmd, projectCwd, onProgress } = opts;
+    const { log, dataDir, userId, restartCmd, projectCwd, onProgress, serviceName } = opts;
     const progress = (msg) => {
         onProgress?.(msg);
         log?.info({}, `update-command: ${msg}`);
@@ -123,7 +123,7 @@ export async function handleUpdateCommand(cmd, opts = {}) {
                     });
                 }
                 else {
-                    const [restartBin, restartArgList] = getRestartCmdArgs();
+                    const [restartBin, restartArgList] = getRestartCmdArgs(serviceName);
                     execFile(restartBin, restartArgList, (err) => {
                         if (err)
                             log?.error({ err }, 'update-command: restart failed');
@@ -180,7 +180,7 @@ export async function handleUpdateCommand(cmd, opts = {}) {
                 });
             }
             else {
-                const [restartBin, restartArgList] = getRestartCmdArgs();
+                const [restartBin, restartArgList] = getRestartCmdArgs(serviceName);
                 execFile(restartBin, restartArgList, (err) => {
                     if (err)
                         log?.error({ err }, 'update-command: restart failed');

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

@@ -249,7 +249,7 @@ describe('handleUpdateCommand: apply', () => {
             const restartCall = calls.find(([cmd, args]) => cmd === 'launchctl' && args.includes('kickstart'));
             expect(restartCall).toBeDefined();
             expect(restartCall[1]).toContain('-k');
-            expect(restartCall[1].some((a) => a.includes('com.discoclaw.agent'))).toBe(true);
+            expect(restartCall[1].some((a) => a.includes('com.discoclaw.discoclaw'))).toBe(true);
         }
         finally {
             Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
@@ -266,6 +266,17 @@ describe('handleUpdateCommand: apply', () => {
         expect(shCall).toBeDefined();
         expect(shCall[1]).toEqual(['-c', 'sudo systemctl restart discoclaw']);
     });
+    it('deferred passes custom serviceName to getRestartCmdArgs (git-managed)', async () => {
+        const { execFile } = await import('node:child_process');
+        const mock = mockAllSuccess();
+        execFile.mockImplementation(mock);
+        const result = await handleUpdateCommand({ action: 'apply' }, { serviceName: 'discoclaw-beta' });
+        result.deferred();
+        const calls = execFile.mock.calls;
+        const restartCall = calls.find(([cmd, args]) => cmd === 'systemctl' && args.includes('restart'));
+        expect(restartCall).toBeDefined();
+        expect(restartCall[1]).toEqual(['--user', 'restart', 'discoclaw-beta']);
+    });
     it('calls onProgress callback for each step', async () => {
         const { execFile } = await import('node:child_process');
         execFile.mockImplementation(mockAllSuccess());
@@ -340,4 +351,18 @@ describe('handleUpdateCommand: npm-managed mode', () => {
         expect(result.reply).toContain('failed');
         expect(result.deferred).toBeUndefined();
     });
+    it('deferred passes custom serviceName to getRestartCmdArgs (npm-managed)', async () => {
+        const { execFile } = await import('node:child_process');
+        execFile.mockImplementation((cmd, args, optsOrCb, maybeCb) => {
+            const cb = typeof optsOrCb === 'function' ? optsOrCb : maybeCb;
+            if (cb)
+                cb(null, '', '');
+        });
+        const result = await handleUpdateCommand({ action: 'apply' }, { serviceName: 'discoclaw-beta' });
+        result.deferred();
+        const calls = execFile.mock.calls;
+        const restartCall = calls.find(([cmd, args]) => cmd === 'systemctl' && args.includes('restart'));
+        expect(restartCall).toBeDefined();
+        expect(restartCall[1]).toEqual(['--user', 'restart', 'discoclaw-beta']);
+    });
 });

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/index.js

@@ -586,6 +586,7 @@ const botParams = {
     workspaceCwd,
     projectCwd: projectRoot,
     updateRestartCmd: process.env.DC_RESTART_CMD,
+    serviceName: cfg.serviceName,
     groupsDir,
     useGroupDirCwd,
     runtimeModel,

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.1",
+  "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