relay-ide 0.1.0

package/dist/test/test/branch-linker.test.js

@@ -0,0 +1,231 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import express from 'express';
+import { createBranchLinkerRouter, invalidateBranchLinkerCache, } from '../server/branch-linker.js';
+import { saveConfig, DEFAULTS } from '../server/config.js';
+let tmpDir;
+let configPath;
+let server;
+let baseUrl;
+const WORKSPACE_PATH_A = '/fake/workspace/repo-a';
+const WORKSPACE_PATH_B = '/fake/workspace/repo-b';
+/**
+ * Creates a mock execAsync that returns configured branch lists per cwd.
+ * - `git branch -a` → returns newline-joined branch names or throws
+ */
+function makeMockExec(opts) {
+    return async (cmd, args, options) => {
+        const command = cmd;
+        const argv = args;
+        const cwd = options.cwd ?? '';
+        if (command === 'git' && argv[0] === 'branch') {
+            if (opts.errorByPath?.[cwd])
+                throw opts.errorByPath[cwd];
+            const branches = opts.branchesByPath?.[cwd] ?? [];
+            return { stdout: branches.join('\n') + '\n', stderr: '' };
+        }
+        throw new Error(`Unexpected exec call: ${command} ${argv.join(' ')}`);
+    };
+}
+function startServer(execAsyncFn, getActiveBranchNames) {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        const deps = {
+            configPath,
+            execAsync: execAsyncFn,
+            ...(getActiveBranchNames ? { getActiveBranchNames } : {}),
+        };
+        app.use('/branch-linker', createBranchLinkerRouter(deps));
+        server = app.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (typeof addr === 'object' && addr) {
+                baseUrl = `http://127.0.0.1:${addr.port}`;
+            }
+            resolve();
+        });
+    });
+}
+function stopServer() {
+    return new Promise((resolve) => {
+        if (server)
+            server.close(() => resolve());
+        else
+            resolve();
+    });
+}
+async function getLinks() {
+    const res = await fetch(`${baseUrl}/branch-linker/links`);
+    return res.json();
+}
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'branch-linker-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+    // Clear any module-level cache before test suite runs
+    invalidateBranchLinkerCache();
+});
+after(async () => {
+    await stopServer();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+test('extracts Jira ticket IDs from branch names', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['dy/fix/ACME-123-auth', 'main'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.ok('ACME-123' in data, 'Should extract ACME-123 from branch name');
+    const links = data['ACME-123'];
+    assert.equal(links.length, 1);
+    assert.equal(links[0].branchName, 'dy/fix/ACME-123-auth');
+    assert.equal(links[0].repoPath, WORKSPACE_PATH_A);
+    assert.equal(links[0].repoName, 'repo-a');
+});
+test('extracts GH issue IDs from gh-N branches', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            // Use a branch that only the GH regex matches (no embedded uppercase-only letters)
+            // to get a single clean GH-42 link. The Jira regex (/[A-Z]{2,}-\d+/gi) would also
+            // match 'gh-42' since the flag is case-insensitive, so we use a prefix that isolates
+            // the GH regex match by starting with 'gh-' at the very start of the branch name.
+            [WORKSPACE_PATH_A]: ['gh-42-login-fix'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.ok('GH-42' in data, 'Should extract GH-42 from branch name');
+    const links = data['GH-42'];
+    // Only the GH regex matches this branch — the Jira regex explicitly excludes 'GH'
+    // to avoid double-matching. Verify all links point to the correct branch and repo.
+    assert.ok(links.length >= 1, 'Should have at least one GH-42 link');
+    assert.ok(links.every((l) => l.branchName === 'gh-42-login-fix'), 'All links should reference the correct branch');
+    assert.ok(links.every((l) => l.repoPath === WORKSPACE_PATH_A), 'All links should reference the correct repo');
+});
+test('same ticket in two repos yields array of 2 BranchLinks', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['feature/PROJ-99-payment'],
+            [WORKSPACE_PATH_B]: ['bugfix/PROJ-99-payment-fix'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.ok('PROJ-99' in data, 'Should have PROJ-99 key');
+    const links = data['PROJ-99'];
+    assert.equal(links.length, 2, 'Should have 2 BranchLinks for the same ticket across 2 repos');
+    const repoPaths = links.map((l) => l.repoPath).sort();
+    assert.deepEqual(repoPaths, [WORKSPACE_PATH_A, WORKSPACE_PATH_B].sort());
+});
+test('ignores branches without ticket IDs', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['main', 'develop', 'chore/cleanup', 'feature/new-ui'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.equal(Object.keys(data).length, 0, 'Plain branches should produce no ticket links');
+});
+test('hasActiveSession true when branch is in active set', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const activeBranch = 'feature/ACTIVE-1-work';
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: [activeBranch, 'feature/INACTIVE-2-other'],
+        },
+    });
+    const getActiveBranchNames = () => {
+        return new Map([[WORKSPACE_PATH_A, new Set([activeBranch])]]);
+    };
+    await startServer(exec, getActiveBranchNames);
+    const data = await getLinks();
+    const activeLinks = data['ACTIVE-1'];
+    assert.ok(activeLinks, 'Should have ACTIVE-1 ticket');
+    assert.equal(activeLinks.length, 1);
+    assert.equal(activeLinks[0].hasActiveSession, true, 'Active branch should have hasActiveSession true');
+    const inactiveLinks = data['INACTIVE-2'];
+    assert.ok(inactiveLinks, 'Should have INACTIVE-2 ticket');
+    assert.equal(inactiveLinks[0].hasActiveSession, false, 'Inactive branch should have hasActiveSession false');
+});
+test('invalidateBranchLinkerCache forces fresh scan', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    let gitCallCount = 0;
+    const baseExec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['feature/SCAN-1-fresh'],
+        },
+    });
+    const countingExec = async (...args) => {
+        const [cmd] = args;
+        if (cmd === 'git')
+            gitCallCount++;
+        return baseExec(...args);
+    };
+    await startServer(countingExec);
+    // First request — populates module-level cache
+    const first = await getLinks();
+    assert.ok('SCAN-1' in first, 'Should have SCAN-1 after first request');
+    assert.equal(gitCallCount, 1, 'git should be called once on first request');
+    // Second request — served from cache
+    const second = await getLinks();
+    assert.ok('SCAN-1' in second);
+    assert.equal(gitCallCount, 1, 'git should not be called again within TTL');
+    // Invalidate cache
+    invalidateBranchLinkerCache();
+    // Third request — cache is cleared, should fetch fresh
+    const third = await getLinks();
+    assert.ok('SCAN-1' in third);
+    assert.equal(gitCallCount, 2, 'git should be called again after cache invalidation');
+});
+test('returns empty object when no workspaces', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [],
+    });
+    // execAsync should never be called here
+    const exec = makeMockExec({});
+    await startServer(exec);
+    const data = await getLinks();
+    assert.equal(Object.keys(data).length, 0, 'Should return empty object when no workspaces configured');
+});

package/dist/test/test/branch-rename.test.js

@@ -0,0 +1,45 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { MOUNTAIN_NAMES } from '../server/types.js';
+import { branchToDisplayName } from '../server/git.js';
+describe('MOUNTAIN_NAMES', () => {
+    test('contains 30 mountain names', () => {
+        assert.equal(MOUNTAIN_NAMES.length, 30);
+    });
+    test('all names are lowercase kebab-case', () => {
+        for (const name of MOUNTAIN_NAMES) {
+            assert.match(name, /^[a-z][a-z0-9-]*$/, `Mountain name "${name}" is not kebab-case`);
+        }
+    });
+    test('no duplicate names', () => {
+        const unique = new Set(MOUNTAIN_NAMES);
+        assert.equal(unique.size, MOUNTAIN_NAMES.length);
+    });
+    test('cycling wraps around at array length', () => {
+        let idx = 28;
+        const name1 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        idx++;
+        const name2 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        idx++;
+        const name3 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        assert.equal(name1, 'whitney');
+        assert.equal(name2, 'hood');
+        assert.equal(name3, 'everest'); // wraps back to start
+    });
+});
+describe('branchToDisplayName', () => {
+    test('converts kebab-case to sentence case', () => {
+        assert.equal(branchToDisplayName('fix-mobile-scroll-bug'), 'Fix mobile scroll bug');
+    });
+    test('strips common branch prefixes', () => {
+        assert.equal(branchToDisplayName('feature/add-auth'), 'Add auth');
+        assert.equal(branchToDisplayName('fix/api-timeout'), 'Api timeout');
+        assert.equal(branchToDisplayName('chore/update-deps'), 'Update deps');
+    });
+    test('handles simple names', () => {
+        assert.equal(branchToDisplayName('lhotse'), 'Lhotse');
+    });
+    test('handles underscores', () => {
+        assert.equal(branchToDisplayName('fix_the_thing'), 'Fix the thing');
+    });
+});

package/dist/test/test/clipboard.test.js

@@ -0,0 +1,12 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { detectClipboardTool, setClipboardImage } from '../server/clipboard.js';
+describe('clipboard', () => {
+    it('detectClipboardTool returns a string or null', () => {
+        const result = detectClipboardTool();
+        assert.ok(result === null || typeof result === 'string');
+    });
+    it('setClipboardImage rejects unsupported mime types', async () => {
+        await assert.rejects(() => setClipboardImage('/tmp/test.txt', 'text/plain'), /Unsupported/);
+    });
+});

package/dist/test/test/config.test.js

@@ -0,0 +1,281 @@
+import { test, before, after, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { DEFAULTS, loadConfig, saveConfig, ensureMetaDir, readMeta, writeMeta, deleteMeta, resolveSessionSettings, deleteWorkspaceSettingKeys } from '../server/config.js';
+let tmpDir;
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-remote-cli-config-test-'));
+});
+afterEach(() => {
+    for (const entry of fs.readdirSync(tmpDir, { withFileTypes: true })) {
+        const fullPath = path.join(tmpDir, entry.name);
+        if (entry.isDirectory()) {
+            fs.rmSync(fullPath, { recursive: true });
+        }
+        else {
+            fs.unlinkSync(fullPath);
+        }
+    }
+});
+after(() => {
+    fs.rmdirSync(tmpDir);
+});
+test('loadConfig loads a JSON config file', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const data = { port: 4000, host: '127.0.0.1' };
+    fs.writeFileSync(configPath, JSON.stringify(data), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.port, 4000);
+    assert.equal(config.host, '127.0.0.1');
+});
+test('loadConfig merges with defaults for missing fields', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({ port: 9000 }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.port, 9000);
+    assert.equal(config.host, DEFAULTS.host);
+    assert.equal(config.cookieTTL, DEFAULTS.cookieTTL);
+    assert.deepEqual(config.repos, DEFAULTS.repos);
+    assert.equal(config.claudeCommand, DEFAULTS.claudeCommand);
+    assert.deepEqual(config.claudeArgs, DEFAULTS.claudeArgs);
+    assert.equal(config.defaultAgent, DEFAULTS.defaultAgent);
+});
+test('loadConfig throws if config file not found', () => {
+    const configPath = path.join(tmpDir, 'nonexistent.json');
+    assert.throws(() => loadConfig(configPath), /Config file not found/);
+});
+test('saveConfig writes JSON with 2-space indent', () => {
+    const configPath = path.join(tmpDir, 'output.json');
+    const config = { port: 3456, host: '0.0.0.0' };
+    saveConfig(configPath, config);
+    const raw = fs.readFileSync(configPath, 'utf8');
+    assert.equal(raw, JSON.stringify(config, null, 2));
+});
+test('DEFAULTS has expected keys and values', () => {
+    assert.equal(DEFAULTS.host, '0.0.0.0');
+    assert.equal(DEFAULTS.port, 3456);
+    assert.equal(DEFAULTS.cookieTTL, '24h');
+    assert.deepEqual(DEFAULTS.repos, []);
+    assert.equal(DEFAULTS.claudeCommand, 'claude');
+    assert.deepEqual(DEFAULTS.claudeArgs, []);
+    assert.equal(DEFAULTS.defaultAgent, 'claude');
+    assert.equal(DEFAULTS.defaultContinue, true);
+    assert.equal(DEFAULTS.defaultYolo, false);
+    assert.equal(DEFAULTS.launchInTmux, false);
+});
+test('loadConfig returns correct defaults for defaultContinue, defaultYolo, and launchInTmux', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({ port: 3456 }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.defaultContinue, true);
+    assert.equal(config.defaultYolo, false);
+    assert.equal(config.launchInTmux, false);
+});
+test('ensureMetaDir creates worktree-meta directory', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    ensureMetaDir(configPath);
+    const metaPath = path.join(tmpDir, 'worktree-meta');
+    assert.ok(fs.existsSync(metaPath));
+});
+test('writeMeta creates and readMeta reads metadata file', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const meta = { worktreePath: '/tmp/test-worktree', displayName: 'My Feature', lastActivity: '2026-02-22T00:00:00.000Z' };
+    writeMeta(configPath, meta);
+    const read = readMeta(configPath, '/tmp/test-worktree');
+    assert.deepEqual(read, meta);
+});
+test('readMeta returns null for non-existent metadata', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const result = readMeta(configPath, '/no/such/worktree');
+    assert.equal(result, null);
+});
+test('writeMeta overwrites existing metadata', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    writeMeta(configPath, { worktreePath: '/tmp/wt', displayName: 'Old Name', lastActivity: '2026-01-01T00:00:00.000Z' });
+    writeMeta(configPath, { worktreePath: '/tmp/wt', displayName: 'New Name', lastActivity: '2026-02-22T00:00:00.000Z' });
+    const read = readMeta(configPath, '/tmp/wt');
+    assert.equal(read.displayName, 'New Name');
+    assert.equal(read.lastActivity, '2026-02-22T00:00:00.000Z');
+});
+test('deleteMeta removes metadata file', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    writeMeta(configPath, { worktreePath: '/tmp/del-test', displayName: 'To Delete', lastActivity: '2026-02-22T00:00:00.000Z' });
+    assert.ok(readMeta(configPath, '/tmp/del-test'));
+    deleteMeta(configPath, '/tmp/del-test');
+    assert.equal(readMeta(configPath, '/tmp/del-test'), null);
+});
+test('deleteMeta is a no-op for non-existent metadata', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    assert.doesNotThrow(() => deleteMeta(configPath, '/no/such/path'));
+});
+test('resolveSessionSettings returns global defaults when no workspace or overrides', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        defaultAgent: 'claude',
+        defaultContinue: true,
+        defaultYolo: false,
+        launchInTmux: false,
+        claudeArgs: [],
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    const result = resolveSessionSettings(config, '/some/repo', {});
+    assert.equal(result.agent, 'claude');
+    assert.equal(result.yolo, false);
+    assert.equal(result.continue, true);
+    assert.equal(result.useTmux, false);
+    assert.deepEqual(result.claudeArgs, []);
+});
+test('resolveSessionSettings applies workspace overrides over globals', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        defaultAgent: 'claude',
+        defaultYolo: false,
+        defaultContinue: true,
+        launchInTmux: false,
+        claudeArgs: [],
+        workspaceSettings: {
+            '/my/repo': { defaultYolo: true, defaultAgent: 'codex' },
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    const result = resolveSessionSettings(config, '/my/repo', {});
+    assert.equal(result.agent, 'codex');
+    assert.equal(result.yolo, true);
+    assert.equal(result.continue, true);
+});
+test('resolveSessionSettings explicit overrides beat workspace settings', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        defaultAgent: 'claude',
+        defaultYolo: true,
+        defaultContinue: true,
+        launchInTmux: false,
+        claudeArgs: [],
+        workspaceSettings: {
+            '/my/repo': { defaultYolo: true },
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    const result = resolveSessionSettings(config, '/my/repo', { yolo: false });
+    assert.equal(result.yolo, false);
+});
+test('resolveSessionSettings uses override claudeArgs, not global', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        defaultAgent: 'claude',
+        defaultYolo: false,
+        defaultContinue: true,
+        launchInTmux: false,
+        claudeArgs: ['--global-arg'],
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    const result = resolveSessionSettings(config, '/some/repo', { claudeArgs: ['--custom'] });
+    assert.deepEqual(result.claudeArgs, ['--custom']);
+});
+test('resolveSessionSettings falls through to globals when no workspace exists', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        defaultAgent: 'codex',
+        defaultYolo: true,
+        defaultContinue: false,
+        launchInTmux: true,
+        claudeArgs: ['--verbose'],
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    const result = resolveSessionSettings(config, '/nonexistent/repo', {});
+    assert.equal(result.agent, 'codex');
+    assert.equal(result.yolo, true);
+    assert.equal(result.continue, false);
+    assert.equal(result.useTmux, true);
+    assert.deepEqual(result.claudeArgs, ['--verbose']);
+});
+test('deleteWorkspaceSettingKeys removes specified keys', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const config = {
+        ...DEFAULTS,
+        workspaceSettings: {
+            '/my/repo': { defaultYolo: true, defaultAgent: 'codex', branchPrefix: 'dy/' },
+        },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config), 'utf8');
+    deleteWorkspaceSettingKeys(configPath, config, '/my/repo', ['defaultYolo', 'defaultAgent']);
+    assert.equal(config.workspaceSettings['/my/repo'].defaultYolo, undefined);
+    assert.equal(config.workspaceSettings['/my/repo'].defaultAgent, undefined);
+    assert.equal(config.workspaceSettings['/my/repo'].branchPrefix, 'dy/');
+});
+test('deleteWorkspaceSettingKeys removes entire workspace entry when empty', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const config = {
+        ...DEFAULTS,
+        workspaceSettings: {
+            '/my/repo': { defaultYolo: true },
+        },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config), 'utf8');
+    deleteWorkspaceSettingKeys(configPath, config, '/my/repo', ['defaultYolo']);
+    assert.equal(config.workspaceSettings['/my/repo'], undefined);
+});
+test('deleteWorkspaceSettingKeys is no-op for nonexistent workspace', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const config = { ...DEFAULTS };
+    fs.writeFileSync(configPath, JSON.stringify(config), 'utf8');
+    assert.doesNotThrow(() => deleteWorkspaceSettingKeys(configPath, config, '/no/such/repo', ['defaultYolo']));
+});
+test('workspaceGroups with valid paths loads cleanly', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/a/repo', '/b/repo'],
+        workspaceGroups: {
+            'Group A': ['/a/repo'],
+            'Group B': ['/b/repo'],
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.deepEqual(config.workspaceGroups['Group A'], ['/a/repo']);
+    assert.deepEqual(config.workspaceGroups['Group B'], ['/b/repo']);
+});
+test('workspaceGroups with invalid path filters it out', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/valid/repo'],
+        workspaceGroups: {
+            'My Group': ['/valid/repo', '/not/in/workspaces'],
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.deepEqual(config.workspaceGroups['My Group'], ['/valid/repo']);
+});
+test('workspaceGroups with duplicate path keeps first-group winner', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/shared/repo'],
+        workspaceGroups: {
+            'First': ['/shared/repo'],
+            'Second': ['/shared/repo'],
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.deepEqual(config.workspaceGroups['First'], ['/shared/repo']);
+    assert.equal(config.workspaceGroups['Second'], undefined);
+});
+test('workspaceGroups undefined produces no errors', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/some/repo'],
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.workspaceGroups, undefined);
+});
+test('workspaceGroups with all-invalid paths removes empty group', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/valid/repo'],
+        workspaceGroups: {
+            'Ghost Group': ['/not/here', '/also/not/here'],
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.workspaceGroups['Ghost Group'], undefined);
+});