@agenthippo-ai/agenthippo 0.1.0

package/out/test/sync-switch.test.js

@@ -0,0 +1,251 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Sync Switch Tests
+ *
+ * Tests for switching between agents and verifying derived directory content updates.
+ * These tests verify that switchToPack correctly syncs the target agent's content to
+ * the workspace-root .claude/ and .codex/ directories.
+ */
+require("mocha");
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const paths_1 = require("../agentpack/paths");
+const manifest_fixtures_1 = require("./helpers/manifest-fixtures");
+// Shim vscode module for SyncService
+const Module = require('module');
+const originalRequire = Module.prototype.require;
+const fakeVscode = {
+    window: {
+        showInformationMessage: () => undefined,
+        showErrorMessage: () => undefined,
+    },
+    workspace: {
+        getConfiguration: () => ({
+            get: (_key, defaultValue) => defaultValue,
+            inspect: (_key) => undefined,
+        }),
+        fs: {
+            stat: async () => ({ type: 1 }), // FileType.File
+            readDirectory: async () => [],
+        },
+    },
+    commands: {
+        executeCommand: async () => undefined,
+    },
+    Uri: {
+        file: (p) => ({ fsPath: p, scheme: 'file' }),
+    },
+    FileType: {
+        File: 1,
+        Directory: 2,
+        SymbolicLink: 64,
+    },
+};
+Module.prototype.require = function (request) {
+    if (request === 'vscode') {
+        return fakeVscode;
+    }
+    return originalRequire.apply(this, arguments);
+};
+// Dynamic imports after stubbing vscode
+const { SyncService } = require('../sync');
+// -------------------------------------------------------------------------
+// Helper Functions
+// -------------------------------------------------------------------------
+function makeTempWorkspace() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'agentide-sync-test-'));
+}
+function createOutputChannel() {
+    const lines = [];
+    return {
+        lines,
+        appendLine: (msg) => {
+            lines.push(msg);
+            if (process.env.DEBUG_SYNC_TEST) {
+                console.log(msg);
+            }
+        },
+        show: () => { },
+    };
+}
+function setupAgent(workspaceRoot, agentId, agentsContent) {
+    const agentRoot = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', agentId);
+    fs.mkdirSync(agentRoot, { recursive: true });
+    // Write AGENTS.md with unique content for this agent
+    fs.writeFileSync(path.join(agentRoot, 'AGENTS.md'), agentsContent, 'utf8');
+    // Write minimal agent.yaml
+    const agentYaml = (0, manifest_fixtures_1.createTestAgentYaml)({
+        name: agentId,
+        version: '0.1.0',
+        engine: 'claude',
+        model: 'claude-sonnet-4-20250514',
+    });
+    fs.writeFileSync(path.join(agentRoot, 'agent.yaml'), agentYaml, 'utf8');
+}
+function readDerivedRulesContent(workspaceRoot, engineDir, rulesFile) {
+    const filePath = path.join(workspaceRoot, engineDir, rulesFile);
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function cleanupWorkspace(workspaceRoot) {
+    try {
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+    catch {
+        // ignore cleanup errors
+    }
+}
+// -------------------------------------------------------------------------
+// Tests
+// -------------------------------------------------------------------------
+suite('SyncService switchToPack', () => {
+    let workspaceRoot;
+    let syncService;
+    let outputChannel;
+    const PACK_ID = 'test-pack';
+    const PACK_CONTENT = '# Test Pack Agent\n\nThis is the TEST PACK content.\n';
+    const DEFAULT_CONTENT = '# Default Agent\n\nThis is the DEFAULT content.\n';
+    setup(() => {
+        workspaceRoot = makeTempWorkspace();
+        syncService = new SyncService();
+        outputChannel = createOutputChannel();
+        // Set up both the pack and default agent
+        setupAgent(workspaceRoot, PACK_ID, PACK_CONTENT);
+        setupAgent(workspaceRoot, 'default', DEFAULT_CONTENT);
+    });
+    teardown(() => {
+        cleanupWorkspace(workspaceRoot);
+    });
+    test('switching to pack syncs pack content to derived directories', async () => {
+        // Switch to the pack
+        const result = await syncService.switchToPack(workspaceRoot, PACK_ID, outputChannel);
+        // Verify return value
+        assert.strictEqual(result, PACK_ID, 'switchToPack should return the pack ID');
+        // Verify .claude/CLAUDE.md has pack content
+        const claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent, '.claude/CLAUDE.md should exist');
+        assert.ok(claudeContent.includes('TEST PACK'), '.claude/CLAUDE.md should contain pack content');
+        assert.ok(!claudeContent.includes('DEFAULT'), '.claude/CLAUDE.md should NOT contain default content');
+        // Verify .codex/AGENTS.md has pack content
+        const codexContent = readDerivedRulesContent(workspaceRoot, '.codex', 'AGENTS.md');
+        assert.ok(codexContent, '.codex/AGENTS.md should exist');
+        assert.ok(codexContent.includes('TEST PACK'), '.codex/AGENTS.md should contain pack content');
+    });
+    test('switching to default syncs default content to derived directories', async () => {
+        // First switch to the pack
+        await syncService.switchToPack(workspaceRoot, PACK_ID, outputChannel);
+        // Verify pack content is there
+        let claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent?.includes('TEST PACK'), 'Should have pack content before switching');
+        // Now switch to default
+        const result = await syncService.switchToPack(workspaceRoot, 'default', outputChannel);
+        // Verify return value
+        assert.strictEqual(result, undefined, 'switchToPack with default should return undefined');
+        // Verify .claude/CLAUDE.md now has DEFAULT content
+        claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent, '.claude/CLAUDE.md should exist after switch');
+        assert.ok(claudeContent.includes('DEFAULT'), '.claude/CLAUDE.md should contain default content');
+        assert.ok(!claudeContent.includes('TEST PACK'), '.claude/CLAUDE.md should NOT contain pack content anymore');
+        // Verify .codex/AGENTS.md has default content
+        const codexContent = readDerivedRulesContent(workspaceRoot, '.codex', 'AGENTS.md');
+        assert.ok(codexContent, '.codex/AGENTS.md should exist');
+        assert.ok(codexContent.includes('DEFAULT'), '.codex/AGENTS.md should contain default content');
+        assert.ok(!codexContent.includes('TEST PACK'), '.codex/AGENTS.md should NOT contain pack content');
+    });
+    test('switching to undefined syncs default content (same as "default")', async () => {
+        // First switch to the pack
+        await syncService.switchToPack(workspaceRoot, PACK_ID, outputChannel);
+        // Verify pack content is there
+        let claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent?.includes('TEST PACK'), 'Should have pack content before switching');
+        // Switch to undefined (should behave like 'default')
+        const result = await syncService.switchToPack(workspaceRoot, undefined, outputChannel);
+        // Verify return value
+        assert.strictEqual(result, undefined, 'switchToPack with undefined should return undefined');
+        // Verify .claude/CLAUDE.md now has DEFAULT content
+        claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent, '.claude/CLAUDE.md should exist after switch');
+        assert.ok(claudeContent.includes('DEFAULT'), '.claude/CLAUDE.md should contain default content');
+        assert.ok(!claudeContent.includes('TEST PACK'), '.claude/CLAUDE.md should NOT contain pack content');
+    });
+    test('multiple switches correctly update derived directories each time', async () => {
+        // Switch to pack
+        await syncService.switchToPack(workspaceRoot, PACK_ID, outputChannel);
+        let claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent?.includes('TEST PACK'), 'First switch: should have pack content');
+        // Switch to default
+        await syncService.switchToPack(workspaceRoot, 'default', outputChannel);
+        claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent?.includes('DEFAULT'), 'Second switch: should have default content');
+        assert.ok(!claudeContent?.includes('TEST PACK'), 'Second switch: should NOT have pack content');
+        // Switch back to pack
+        await syncService.switchToPack(workspaceRoot, PACK_ID, outputChannel);
+        claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent?.includes('TEST PACK'), 'Third switch: should have pack content again');
+        assert.ok(!claudeContent?.includes('DEFAULT'), 'Third switch: should NOT have default content');
+        // Switch back to default one more time
+        await syncService.switchToPack(workspaceRoot, 'default', outputChannel);
+        claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent?.includes('DEFAULT'), 'Fourth switch: should have default content again');
+    });
+    test('switching to non-existent pack falls back to default', async () => {
+        // First set up pack content
+        await syncService.switchToPack(workspaceRoot, PACK_ID, outputChannel);
+        let claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent?.includes('TEST PACK'), 'Should have pack content initially');
+        // Try to switch to a non-existent pack
+        const result = await syncService.switchToPack(workspaceRoot, 'non-existent-pack', outputChannel);
+        // Should fall back to default
+        assert.strictEqual(result, undefined, 'Should return undefined when falling back to default');
+        // Should have default content
+        claudeContent = readDerivedRulesContent(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(claudeContent?.includes('DEFAULT'), 'Should fall back to default content');
+        assert.ok(!claudeContent?.includes('TEST PACK'), 'Should NOT have pack content after fallback');
+        // Verify warning was logged
+        const hasWarning = outputChannel.lines.some(line => line.includes('Warning') && line.includes('non-existent-pack'));
+        assert.ok(hasWarning, 'Should log warning about non-existent pack');
+    });
+});

package/out/test/teamViewDiscovery.test.js

@@ -0,0 +1,90 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const fs_1 = require("fs");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const teamViewDiscovery_1 = require("../analytics/dashboard/teamViewDiscovery");
+suite('teamViewDiscovery', () => {
+    let tempDir;
+    suiteSetup(async () => {
+        tempDir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'agentide-team-discovery-'));
+    });
+    suiteTeardown(async () => {
+        await fs_1.promises.rm(tempDir, { recursive: true, force: true });
+    });
+    test('discovers views whose view.yaml includes the team or fleet tag', async () => {
+        const root = path.join(tempDir, 'analytics');
+        const viewsDir = path.join(root, 'views');
+        await fs_1.promises.mkdir(path.join(viewsDir, 'live-fleet-2', 'scripts'), { recursive: true });
+        await fs_1.promises.mkdir(path.join(viewsDir, 'other-view', 'scripts'), { recursive: true });
+        await fs_1.promises.writeFile(path.join(viewsDir, 'live-fleet-2', 'view.yaml'), `id: live-fleet-2\nname: Live Fleet 2\nscope: global\ntags: [fleet, ${teamViewDiscovery_1.TEAM_VIEW_TAG}]\nscripts: [live-fleet-2-widget.cjs]\n`, 'utf-8');
+        await fs_1.promises.writeFile(path.join(viewsDir, 'other-view', 'view.yaml'), `id: other-view\nname: Other\nscope: global\ntags: [spotlight]\nscripts: [other.js]\n`, 'utf-8');
+        const discovered = await (0, teamViewDiscovery_1.discoverTeamTaggedViews)([root]);
+        assert.strictEqual(discovered.length, 1);
+        assert.strictEqual(discovered[0]?.id, 'live-fleet-2');
+        assert.strictEqual(discovered[0]?.name, 'Live Fleet 2');
+    });
+    test('discovers views tagged fleet without team', async () => {
+        const root = path.join(tempDir, 'fleet-only');
+        const viewsDir = path.join(root, 'views', 'live-fleet-2');
+        await fs_1.promises.mkdir(viewsDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(viewsDir, 'view.yaml'), `id: live-fleet-2\nname: Live Fleet 2\nscope: global\ntags: [${teamViewDiscovery_1.FLEET_VIEW_TAG}, spotlight]\nscripts: [live-fleet-2-widget.cjs]\n`, 'utf-8');
+        const discovered = await (0, teamViewDiscovery_1.discoverTeamTaggedViews)([root]);
+        assert.strictEqual(discovered.length, 1);
+        assert.strictEqual(discovered[0]?.id, 'live-fleet-2');
+    });
+    test('workspace-scoped view overrides global entry with the same id', async () => {
+        const globalRoot = path.join(tempDir, 'global-analytics');
+        const workspaceRoot = path.join(tempDir, 'workspace-analytics');
+        for (const [root, scope, name] of [
+            [globalRoot, 'global', 'Global Name'],
+            [workspaceRoot, 'workspace', 'Workspace Name'],
+        ]) {
+            const viewsDir = path.join(root, 'views', 'shared-fleet');
+            await fs_1.promises.mkdir(viewsDir, { recursive: true });
+            await fs_1.promises.writeFile(path.join(viewsDir, 'view.yaml'), `id: shared-fleet\nname: ${name}\nscope: ${scope}\ntags: [${teamViewDiscovery_1.TEAM_VIEW_TAG}]\nscripts: [${scope}-widget.js]\n`, 'utf-8');
+        }
+        const discovered = await (0, teamViewDiscovery_1.discoverTeamTaggedViews)([globalRoot, workspaceRoot]);
+        assert.strictEqual(discovered.length, 1);
+        assert.strictEqual(discovered[0]?.scope, 'workspace');
+        assert.strictEqual(discovered[0]?.name, 'Workspace Name');
+    });
+});

package/out/test/toolPath.test.js

@@ -0,0 +1,120 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Tool Path Test Suite
+ *
+ *  Tests for augmentPathForTools() and the env-spread invariant in dashboard provider.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const toolPath_1 = require("../utils/toolPath");
+suite('augmentPathForTools', () => {
+    const sep = path.delimiter;
+    const home = os.homedir();
+    test('prepends candidate dirs not already in PATH', () => {
+        const result = (0, toolPath_1.augmentPathForTools)('/usr/bin');
+        const parts = result.split(sep);
+        assert.strictEqual(parts[parts.length - 1], '/usr/bin', 'original PATH stays at the end');
+        assert.ok(parts.length > 1, 'at least one candidate dir was prepended');
+    });
+    test('does not duplicate dirs already present in PATH', () => {
+        const localBin = path.join(home, '.local', 'bin');
+        const input = `${localBin}${sep}/usr/bin`;
+        const result = (0, toolPath_1.augmentPathForTools)(input);
+        const occurrences = result.split(sep).filter(p => p === localBin).length;
+        assert.strictEqual(occurrences, 1, '~/.local/bin should appear exactly once');
+    });
+    test('handles empty PATH without leading delimiter', () => {
+        const result = (0, toolPath_1.augmentPathForTools)('');
+        assert.ok(!result.startsWith(sep), 'no leading delimiter when input is empty');
+        assert.ok(result.length > 0, 'returns at least one candidate dir');
+    });
+    test('returns input unchanged when all candidates already present', () => {
+        // Build a PATH that contains every candidate dir we'd add.
+        const augmented = (0, toolPath_1.augmentPathForTools)('');
+        const result = (0, toolPath_1.augmentPathForTools)(augmented);
+        assert.strictEqual(result, augmented, 'no-op when candidates are all already present');
+    });
+    test('uses platform-correct delimiter', () => {
+        const result = (0, toolPath_1.augmentPathForTools)(`a${sep}b`);
+        // Result must be parseable with the same separator.
+        const parts = result.split(sep);
+        assert.ok(parts.includes('a') && parts.includes('b'), 'original entries survive split');
+    });
+    test('candidate list matches platform', () => {
+        const result = (0, toolPath_1.augmentPathForTools)('');
+        const parts = result.split(sep);
+        if (process.platform === 'win32') {
+            assert.ok(parts.some(p => p.toLowerCase().includes('winget') || p.toLowerCase().includes('scoop') || p.endsWith('uv')), 'windows candidate list should include winget/scoop/uv-specific dirs');
+        }
+        else {
+            assert.ok(parts.includes('/opt/homebrew/bin') || parts.includes('/usr/local/bin'), 'unix candidate list should include Homebrew dirs');
+            assert.ok(parts.some(p => p === path.join(home, '.local', 'bin')), 'unix candidate list should include ~/.local/bin');
+            assert.ok(parts.some(p => p === path.join(home, '.uv', 'bin')), 'unix candidate list should include ~/.uv/bin (uv self-install)');
+        }
+    });
+});
+// =============================================================================
+// Regression guard: dashboard provider must spread process.env when building
+// the script environment. If env is set without the spread, child Python
+// processes lose HOME/USER/locale/etc. and break in subtle ways.
+// =============================================================================
+suite('dashboard provider env spread (regression guard)', () => {
+    // Tests run from out/test, so walk up to extension root then into src/.
+    const extensionRoot = path.resolve(__dirname, '..', '..');
+    const providerPath = path.join(extensionRoot, 'src', 'analytics', 'dashboard', 'provider.ts');
+    const indexingPath = path.join(extensionRoot, 'src', 'analytics', 'dashboard', 'indexingService.ts');
+    test('provider.ts buildScriptEnvironment spreads process.env', () => {
+        const src = fs.readFileSync(providerPath, 'utf8');
+        const builderIdx = src.indexOf('buildScriptEnvironment');
+        assert.ok(builderIdx >= 0, 'buildScriptEnvironment must exist in provider.ts');
+        // Look at the ~120 lines following the declaration for the env return.
+        const window = src.slice(builderIdx, builderIdx + 6000);
+        assert.ok(/\.\.\.process\.env/.test(window), 'buildScriptEnvironment must spread process.env so children inherit HOME/USER/locale');
+        assert.ok(/augmentPathForTools\(/.test(window), 'buildScriptEnvironment must augment PATH via augmentPathForTools');
+    });
+    test('indexingService.ts indexing subprocess spreads process.env', () => {
+        const src = fs.readFileSync(indexingPath, 'utf8');
+        // Find the env: { ... } block and confirm it spreads process.env + augments PATH.
+        const envBlock = /env:\s*\{[\s\S]{0,400}?\}/m.exec(src);
+        assert.ok(envBlock, 'indexingService should set env on the indexing subprocess');
+        assert.ok(/\.\.\.\(?\s*process\.env/.test(envBlock[0]), 'indexing subprocess env must spread process.env');
+        assert.ok(/augmentPathForTools\(/.test(envBlock[0]), 'indexing subprocess env must augment PATH via augmentPathForTools');
+    });
+});