discoclaw 0.2.0 → 0.2.2

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

@@ -119,8 +119,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 +160,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 +205,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 +273,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 {
@@ -121,6 +121,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 +343,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/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/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/npm-managed.js

@@ -1,5 +1,8 @@
 import { execa } from 'execa';
+import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 const _require = createRequire(import.meta.url);
 /**
  * Returns the version string from the nearest package.json.
@@ -14,32 +17,14 @@ export function getLocalVersion() {
         return 'unknown';
     }
 }
-/**
- * Returns the npm global node_modules root directory, or null on failure.
- */
-async function getNpmGlobalRoot() {
-    try {
-        const result = await execa('npm', ['root', '-g']);
-        const root = result.stdout.trim();
-        return root || null;
-    }
-    catch {
-        return null;
-    }
-}
 /**
  * Returns true when the running process was installed via `npm install -g`.
- * Detection: checks whether process.argv[1] is rooted under the npm global
- * node_modules directory returned by `npm root -g`.
+ * Detection: source installs have a `.git` directory at the package root;
+ * npm-published packages do not (`.git` is excluded from the `files` array).
  */
 export async function isNpmManaged() {
-    const globalRoot = await getNpmGlobalRoot();
-    if (!globalRoot)
-        return false;
-    const script = process.argv[1];
-    if (!script)
-        return false;
-    return script.startsWith(globalRoot);
+    const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+    return !existsSync(path.join(packageRoot, '.git'));
 }
 /**
  * Fetches the latest published version of discoclaw from the npm registry.

package/dist/npm-managed.test.js

@@ -2,6 +2,9 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 vi.mock('execa', () => ({
     execa: vi.fn(),
 }));
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn(),
+}));
 import { getLocalVersion, getLatestNpmVersion, isNpmManaged, npmGlobalUpgrade } from './npm-managed.js';
 // ---------------------------------------------------------------------------
 // getLocalVersion
@@ -17,42 +20,19 @@ describe('getLocalVersion', () => {
 // isNpmManaged
 // ---------------------------------------------------------------------------
 describe('isNpmManaged', () => {
-    let mockExeca;
+    let mockExistsSync;
     beforeEach(async () => {
-        const mod = await import('execa');
-        mockExeca = mod.execa;
-        mockExeca.mockReset();
-    });
-    it('returns true when process.argv[1] is under the npm global root', async () => {
-        mockExeca.mockResolvedValueOnce({ stdout: '/usr/local/lib/node_modules\n' });
-        const orig = process.argv[1];
-        process.argv[1] = '/usr/local/lib/node_modules/discoclaw/dist/cli/index.js';
-        try {
-            expect(await isNpmManaged()).toBe(true);
-            expect(mockExeca).toHaveBeenCalledWith('npm', ['root', '-g']);
-        }
-        finally {
-            process.argv[1] = orig;
-        }
+        const mod = await import('node:fs');
+        mockExistsSync = mod.existsSync;
+        mockExistsSync.mockReset();
     });
-    it('returns false when process.argv[1] is outside the npm global root', async () => {
-        mockExeca.mockResolvedValueOnce({ stdout: '/usr/local/lib/node_modules\n' });
-        const orig = process.argv[1];
-        process.argv[1] = '/home/user/code/discoclaw/src/index.ts';
-        try {
-            expect(await isNpmManaged()).toBe(false);
-        }
-        finally {
-            process.argv[1] = orig;
-        }
-    });
-    it('returns false when npm root -g fails', async () => {
-        mockExeca.mockRejectedValueOnce(new Error('npm not found'));
+    it('returns false (source install) when .git exists at the package root', async () => {
+        mockExistsSync.mockReturnValue(true);
         expect(await isNpmManaged()).toBe(false);
     });
-    it('returns false when npm root -g returns empty output', async () => {
-        mockExeca.mockResolvedValueOnce({ stdout: '   ' });
-        expect(await isNpmManaged()).toBe(false);
+    it('returns true (npm-managed) when .git does not exist at the package root', async () => {
+        mockExistsSync.mockReturnValue(false);
+        expect(await isNpmManaged()).toBe(true);
     });
 });
 // ---------------------------------------------------------------------------

package/package.json

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