@weldr/runr 0.3.0

package/dist/config/__tests__/presets.test.js

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import { SCOPE_PRESETS } from '../schema.js';
+import { loadConfig } from '../load.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+describe('SCOPE_PRESETS', () => {
+    it('exports all expected presets', () => {
+        const expectedPresets = [
+            'nextjs', 'react', 'drizzle', 'prisma',
+            'vitest', 'jest', 'playwright',
+            'typescript', 'tailwind', 'eslint', 'env'
+        ];
+        for (const preset of expectedPresets) {
+            expect(SCOPE_PRESETS[preset]).toBeDefined();
+            expect(Array.isArray(SCOPE_PRESETS[preset])).toBe(true);
+            expect(SCOPE_PRESETS[preset].length).toBeGreaterThan(0);
+        }
+    });
+    it('vitest preset includes expected patterns', () => {
+        const patterns = SCOPE_PRESETS.vitest;
+        expect(patterns).toContain('vitest.config.*');
+        expect(patterns).toContain('**/*.test.ts');
+    });
+    it('nextjs preset includes expected patterns', () => {
+        const patterns = SCOPE_PRESETS.nextjs;
+        expect(patterns).toContain('next.config.*');
+        expect(patterns).toContain('middleware.ts');
+    });
+});
+describe('preset expansion in loadConfig', () => {
+    it('expands presets into allowlist', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-config-test-'));
+        const configPath = path.join(tmpDir, 'agent.config.json');
+        const config = {
+            agent: { name: 'test', version: '1' },
+            scope: {
+                allowlist: ['src/**'],
+                denylist: [],
+                presets: ['vitest']
+            },
+            verification: { tier0: [], tier1: [], tier2: [] }
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config));
+        try {
+            const loaded = loadConfig(configPath);
+            // Original patterns preserved
+            expect(loaded.scope.allowlist).toContain('src/**');
+            // Preset patterns expanded
+            expect(loaded.scope.allowlist).toContain('vitest.config.*');
+            expect(loaded.scope.allowlist).toContain('**/*.test.ts');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+    it('deduplicates patterns when preset overlaps with allowlist', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-config-test-'));
+        const configPath = path.join(tmpDir, 'agent.config.json');
+        const config = {
+            agent: { name: 'test', version: '1' },
+            scope: {
+                allowlist: ['src/**', 'vitest.config.*'], // Already has one pattern from vitest preset
+                denylist: [],
+                presets: ['vitest']
+            },
+            verification: { tier0: [], tier1: [], tier2: [] }
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config));
+        try {
+            const loaded = loadConfig(configPath);
+            // Count occurrences of vitest.config.*
+            const count = loaded.scope.allowlist.filter(p => p === 'vitest.config.*').length;
+            expect(count).toBe(1); // Should be deduplicated
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+    it('handles multiple presets', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-config-test-'));
+        const configPath = path.join(tmpDir, 'agent.config.json');
+        const config = {
+            agent: { name: 'test', version: '1' },
+            scope: {
+                allowlist: ['src/**'],
+                denylist: [],
+                presets: ['vitest', 'typescript', 'tailwind']
+            },
+            verification: { tier0: [], tier1: [], tier2: [] }
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config));
+        try {
+            const loaded = loadConfig(configPath);
+            // All preset patterns should be present
+            expect(loaded.scope.allowlist).toContain('vitest.config.*');
+            expect(loaded.scope.allowlist).toContain('tsconfig*.json');
+            expect(loaded.scope.allowlist).toContain('tailwind.config.*');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});

package/dist/config/load.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { agentConfigSchema, SCOPE_PRESETS } from './schema.js';
+export function resolveConfigPath(repoPath, configPath) {
+    if (configPath) {
+        return path.resolve(configPath);
+    }
+    // Check new location first: .runr/runr.config.json
+    const newConfigPath = path.resolve(repoPath, '.runr', 'runr.config.json');
+    if (fs.existsSync(newConfigPath)) {
+        return newConfigPath;
+    }
+    // Fall back to old location: .agent/agent.config.json
+    const oldConfigPath = path.resolve(repoPath, '.agent', 'agent.config.json');
+    if (fs.existsSync(oldConfigPath)) {
+        console.warn('\x1b[33m⚠ Deprecation: .agent/agent.config.json is deprecated.\x1b[0m');
+        console.warn('\x1b[33m  Move to: .runr/runr.config.json\x1b[0m\n');
+        return oldConfigPath;
+    }
+    // Default to new path (will error if not found)
+    return newConfigPath;
+}
+/**
+ * Expand scope presets into allowlist patterns.
+ * Unknown presets are warned but not fatal.
+ */
+function expandPresets(config) {
+    const presets = config.scope.presets ?? [];
+    if (presets.length === 0) {
+        return config;
+    }
+    const expandedPatterns = [];
+    const unknownPresets = [];
+    for (const preset of presets) {
+        const patterns = SCOPE_PRESETS[preset];
+        if (patterns) {
+            expandedPatterns.push(...patterns);
+        }
+        else {
+            unknownPresets.push(preset);
+        }
+    }
+    if (unknownPresets.length > 0) {
+        console.warn(`[config] Unknown scope presets (ignored): ${unknownPresets.join(', ')}`);
+        console.warn(`[config] Valid presets: ${Object.keys(SCOPE_PRESETS).join(', ')}`);
+    }
+    // Merge expanded patterns with existing allowlist (deduplicated)
+    const mergedAllowlist = [...new Set([...config.scope.allowlist, ...expandedPatterns])];
+    return {
+        ...config,
+        scope: {
+            ...config.scope,
+            allowlist: mergedAllowlist
+        }
+    };
+}
+export function loadConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config not found: ${configPath}`);
+    }
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    const config = agentConfigSchema.parse(parsed);
+    // Expand presets into allowlist
+    return expandPresets(config);
+}

package/dist/config/schema.js

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+/**
+ * Scope presets - common file patterns for popular frameworks/tools.
+ * These expand the allowlist to include config files that tasks commonly need.
+ */
+export const SCOPE_PRESETS = {
+    // Framework presets
+    nextjs: [
+        'next.config.*',
+        'next-env.d.ts',
+        'middleware.ts',
+        'middleware.js',
+    ],
+    react: [
+        'vite.config.*',
+        'index.html',
+    ],
+    // Database presets
+    drizzle: [
+        'drizzle.config.*',
+        'drizzle/**',
+    ],
+    prisma: [
+        'prisma/**',
+    ],
+    // Testing presets
+    vitest: [
+        'vitest.config.*',
+        'vite.config.*',
+        '**/*.test.ts',
+        '**/*.test.tsx',
+        '**/*.spec.ts',
+        '**/*.spec.tsx',
+    ],
+    jest: [
+        'jest.config.*',
+        'jest.setup.*',
+        '**/*.test.ts',
+        '**/*.test.tsx',
+        '**/*.spec.ts',
+        '**/*.spec.tsx',
+    ],
+    playwright: [
+        'playwright.config.*',
+        'e2e/**',
+        'tests/**',
+    ],
+    // Build/config presets
+    typescript: [
+        'tsconfig*.json',
+    ],
+    tailwind: [
+        'tailwind.config.*',
+        'postcss.config.*',
+    ],
+    eslint: [
+        'eslint.config.*',
+        '.eslintrc*',
+    ],
+    // Environment presets
+    env: [
+        '.env.example',
+        '.env.local.example',
+        '.env.template',
+    ],
+};
+/** Valid preset names */
+export const PRESET_NAMES = Object.keys(SCOPE_PRESETS);
+const riskTriggerSchema = z.object({
+    name: z.string(),
+    patterns: z.array(z.string()),
+    tier: z.enum(['tier0', 'tier1', 'tier2'])
+});
+const verificationSchema = z.object({
+    cwd: z.string().optional(), // Working directory for verification commands (relative to repo root)
+    tier0: z.array(z.string()).default([]),
+    tier1: z.array(z.string()).default([]),
+    tier2: z.array(z.string()).default([]),
+    risk_triggers: z.array(riskTriggerSchema).default([]),
+    max_verify_time_per_milestone: z.number().int().positive().default(600)
+});
+const scopeSchema = z.object({
+    allowlist: z.array(z.string()).default([]),
+    denylist: z.array(z.string()).default([]),
+    lockfiles: z
+        .array(z.string())
+        .default(['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock']),
+    /** Scope presets to include (expands allowlist with common patterns) */
+    presets: z.array(z.string()).default([]),
+    /**
+     * Paths allowed to be dirty AND exempt from scope violations.
+     * These are "env state" - artifacts that don't affect code correctness.
+     * Matches both symlinks and directories (e.g., node_modules and node_modules/).
+     */
+    env_allowlist: z.array(z.string()).default([
+        'node_modules',
+        'node_modules/**',
+        '.next/**',
+        'dist/**',
+        'build/**',
+        '.turbo/**',
+        '.eslintcache',
+        'coverage/**',
+    ]),
+});
+const agentSchema = z.object({
+    name: z.string().default('dual-llm-orchestrator'),
+    version: z.string().default('1')
+});
+const repoSchema = z.object({
+    default_branch: z.string().optional()
+});
+const workerConfigSchema = z.object({
+    bin: z.string(),
+    args: z.array(z.string()).default([]),
+    output: z.enum(['text', 'json', 'jsonl']).default('text')
+});
+const workersSchema = z.object({
+    codex: workerConfigSchema.default({
+        bin: 'codex',
+        args: ['exec', '--full-auto', '--json'],
+        output: 'jsonl'
+    }),
+    claude: workerConfigSchema.default({
+        bin: 'claude',
+        args: ['-p', '--output-format', 'json', '--dangerously-skip-permissions'],
+        output: 'json'
+    })
+});
+// Phase-to-worker mapping - allows configuring which worker handles each phase
+const phasesSchema = z.object({
+    plan: z.enum(['claude', 'codex']).default('claude'),
+    implement: z.enum(['claude', 'codex']).default('codex'),
+    review: z.enum(['claude', 'codex']).default('claude')
+});
+// Resilience settings for auto-resume and failure recovery
+const resilienceSchema = z.object({
+    /** Enable automatic resume on transient failures (stall, worker timeout) */
+    auto_resume: z.boolean().default(false),
+    /** Maximum number of auto-resumes per run (conservative default: 1) */
+    max_auto_resumes: z.number().int().nonnegative().default(1),
+    /** Backoff delays in ms between auto-resume attempts (must be positive integers) */
+    auto_resume_delays_ms: z
+        .array(z.number().int().positive())
+        .nonempty()
+        .default([30000, 120000, 300000]), // 30s, 2min, 5min
+    /** Hard cap on worker call duration in minutes (kills hung workers). Supports decimals for testing. */
+    max_worker_call_minutes: z.number().positive().default(45),
+    /** Maximum review rounds per milestone before stopping with review_loop_detected (default: 2) */
+    max_review_rounds: z.number().int().positive().default(2)
+});
+export const agentConfigSchema = z.object({
+    agent: agentSchema,
+    repo: repoSchema.default({}),
+    scope: scopeSchema,
+    verification: verificationSchema,
+    workers: workersSchema.default({}),
+    phases: phasesSchema.default({}),
+    resilience: resilienceSchema.default({})
+});

package/dist/context/__tests__/artifact.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { writeContextPackArtifact, readContextPackArtifact, formatContextPackStatus } from '../artifact.js';
+describe('writeContextPackArtifact', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'artifact-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('writes full pack when enabled', () => {
+        const pack = {
+            version: 1,
+            generated_at: '2025-12-24T01:00:00.000Z',
+            verification: {
+                tier0: ['pnpm lint'],
+                tier1: [],
+                tier2: []
+            },
+            reference_files: [],
+            scope: {
+                allowlist: ['src/**'],
+                denylist: []
+            },
+            patterns: {
+                tsconfig: null,
+                eslint: null,
+                package_json: null
+            },
+            blockers: {
+                scope_violations: [],
+                lockfile_restrictions: false,
+                common_errors: []
+            }
+        };
+        writeContextPackArtifact(tempDir, pack);
+        const artifactPath = path.join(tempDir, 'artifacts', 'context-pack.json');
+        expect(fs.existsSync(artifactPath)).toBe(true);
+        const content = JSON.parse(fs.readFileSync(artifactPath, 'utf-8'));
+        expect(content.enabled).toBe(true);
+        expect(content.pack_version).toBe(1);
+        expect(content.generated_at).toBe('2025-12-24T01:00:00.000Z');
+        expect(content.estimated_tokens).toBeGreaterThan(0);
+        expect(content.verification.tier0).toEqual(['pnpm lint']);
+    });
+    it('writes disabled stub when pack is null', () => {
+        writeContextPackArtifact(tempDir, null);
+        const artifactPath = path.join(tempDir, 'artifacts', 'context-pack.json');
+        expect(fs.existsSync(artifactPath)).toBe(true);
+        const content = JSON.parse(fs.readFileSync(artifactPath, 'utf-8'));
+        expect(content.enabled).toBe(false);
+        expect(content.pack_version).toBe(1);
+        expect(content.generated_at).toBeDefined();
+        expect(content.verification).toBeUndefined();
+    });
+    it('creates artifacts directory if missing', () => {
+        const artifactsDir = path.join(tempDir, 'artifacts');
+        expect(fs.existsSync(artifactsDir)).toBe(false);
+        writeContextPackArtifact(tempDir, null);
+        expect(fs.existsSync(artifactsDir)).toBe(true);
+    });
+});
+describe('readContextPackArtifact', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'artifact-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('returns null for missing file', () => {
+        const result = readContextPackArtifact(tempDir);
+        expect(result).toBeNull();
+    });
+    it('parses existing artifact', () => {
+        const artifactsDir = path.join(tempDir, 'artifacts');
+        fs.mkdirSync(artifactsDir, { recursive: true });
+        const artifact = {
+            enabled: true,
+            pack_version: 1,
+            generated_at: '2025-12-24T01:00:00.000Z',
+            estimated_tokens: 500
+        };
+        fs.writeFileSync(path.join(artifactsDir, 'context-pack.json'), JSON.stringify(artifact));
+        const result = readContextPackArtifact(tempDir);
+        expect(result).not.toBeNull();
+        expect(result?.enabled).toBe(true);
+        expect(result?.estimated_tokens).toBe(500);
+    });
+    it('returns null for invalid JSON', () => {
+        const artifactsDir = path.join(tempDir, 'artifacts');
+        fs.mkdirSync(artifactsDir, { recursive: true });
+        fs.writeFileSync(path.join(artifactsDir, 'context-pack.json'), 'not json');
+        const result = readContextPackArtifact(tempDir);
+        expect(result).toBeNull();
+    });
+});
+describe('formatContextPackStatus', () => {
+    it('formats null as not found', () => {
+        expect(formatContextPackStatus(null)).toBe('context_pack: (not found)');
+    });
+    it('formats disabled artifact', () => {
+        const artifact = {
+            enabled: false,
+            pack_version: 1,
+            generated_at: '2025-12-24T01:00:00.000Z'
+        };
+        expect(formatContextPackStatus(artifact)).toBe('context_pack: disabled');
+    });
+    it('formats enabled artifact with tokens', () => {
+        const artifact = {
+            enabled: true,
+            pack_version: 1,
+            generated_at: '2025-12-24T01:00:00.000Z',
+            estimated_tokens: 493
+        };
+        expect(formatContextPackStatus(artifact)).toBe('context_pack: present (493 tokens)');
+    });
+    it('handles missing token count', () => {
+        const artifact = {
+            enabled: true,
+            pack_version: 1,
+            generated_at: '2025-12-24T01:00:00.000Z'
+        };
+        expect(formatContextPackStatus(artifact)).toBe('context_pack: present (? tokens)');
+    });
+});

package/dist/context/__tests__/pack.test.js

@@ -0,0 +1,191 @@
+import { describe, it, expect } from 'vitest';
+import path from 'node:path';
+import { buildContextPack, formatContextPackForPrompt, estimatePackTokens } from '../pack.js';
+// Use the actual repo root for integration-style tests
+const REPO_ROOT = path.resolve(__dirname, '../../..');
+describe('buildContextPack', () => {
+    describe('verification commands', () => {
+        it('extracts verification commands from config', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/tactical-grid',
+                config: {
+                    verification: {
+                        tier0: ['pnpm lint', 'pnpm typecheck'],
+                        tier1: ['pnpm test'],
+                        tier2: []
+                    }
+                }
+            });
+            expect(pack.verification.tier0).toEqual(['pnpm lint', 'pnpm typecheck']);
+            expect(pack.verification.tier1).toEqual(['pnpm test']);
+            expect(pack.verification.tier2).toEqual([]);
+        });
+        it('handles missing verification config', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/tactical-grid',
+                config: {}
+            });
+            expect(pack.verification.tier0).toEqual([]);
+            expect(pack.verification.tier1).toEqual([]);
+        });
+    });
+    describe('reference files', () => {
+        it('resolves RNG pattern reference', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/tactical-grid',
+                config: {},
+                references: [{ pattern: 'RNG pattern from deckbuilder' }]
+            });
+            expect(pack.reference_files.length).toBeGreaterThan(0);
+            const rngRef = pack.reference_files.find((r) => r.path.includes('rng.ts'));
+            expect(rngRef).toBeDefined();
+            expect(rngRef?.content).toContain('nextInt');
+            expect(rngRef?.content).toContain('1103515245'); // LCG constant
+        });
+        it('resolves explicit hint path', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/tactical-grid',
+                config: {},
+                references: [
+                    {
+                        pattern: 'custom reference',
+                        hint: 'apps/deckbuilder/src/engine/rng.ts'
+                    }
+                ]
+            });
+            expect(pack.reference_files.length).toBe(1);
+            expect(pack.reference_files[0].path).toBe('apps/deckbuilder/src/engine/rng.ts');
+            expect(pack.reference_files[0].reason).toBe('custom reference');
+        });
+        it('handles unknown pattern gracefully', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/tactical-grid',
+                config: {},
+                references: [{ pattern: 'nonexistent magic pattern' }]
+            });
+            expect(pack.reference_files).toEqual([]);
+        });
+    });
+    describe('scope constraints', () => {
+        it('extracts scope from config', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/tactical-grid',
+                config: {
+                    scope: {
+                        allowlist: ['apps/tactical-grid/**'],
+                        denylist: ['**/node_modules/**']
+                    }
+                }
+            });
+            expect(pack.scope.allowlist).toEqual(['apps/tactical-grid/**']);
+            expect(pack.scope.denylist).toEqual(['**/node_modules/**']);
+        });
+    });
+    describe('config patterns', () => {
+        it('finds nearest tsconfig.json', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/deckbuilder',
+                config: {}
+            });
+            expect(pack.patterns.tsconfig).not.toBeNull();
+            expect(pack.patterns.tsconfig?.path).toContain('tsconfig.json');
+            expect(pack.patterns.tsconfig?.content).toContain('compilerOptions');
+        });
+        it('finds nearest eslint config', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/deckbuilder',
+                config: {}
+            });
+            expect(pack.patterns.eslint).not.toBeNull();
+            expect(pack.patterns.eslint?.path).toMatch(/eslint\.config/);
+        });
+        it('finds nearest package.json', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/deckbuilder',
+                config: {}
+            });
+            expect(pack.patterns.package_json).not.toBeNull();
+            expect(pack.patterns.package_json?.content).toContain('scripts');
+        });
+        it('finds config even for nonexistent target (upward search or fallback)', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/nonexistent-app',
+                config: {}
+            });
+            // Should find config via upward search (repo root) or fallback to deckbuilder
+            expect(pack.patterns.tsconfig).not.toBeNull();
+            expect(pack.patterns.tsconfig?.content).toContain('compilerOptions');
+        });
+    });
+    describe('version and metadata', () => {
+        it('includes version 1', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/tactical-grid',
+                config: {}
+            });
+            expect(pack.version).toBe(1);
+        });
+        it('includes generated_at timestamp', () => {
+            const pack = buildContextPack({
+                repoRoot: REPO_ROOT,
+                targetRoot: 'apps/tactical-grid',
+                config: {}
+            });
+            expect(pack.generated_at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+        });
+    });
+});
+describe('formatContextPackForPrompt', () => {
+    it('formats verification commands', () => {
+        const pack = buildContextPack({
+            repoRoot: REPO_ROOT,
+            targetRoot: 'apps/tactical-grid',
+            config: {
+                verification: {
+                    tier0: ['pnpm lint', 'pnpm typecheck'],
+                    tier1: ['pnpm test']
+                }
+            }
+        });
+        const formatted = formatContextPackForPrompt(pack);
+        expect(formatted).toContain('Verification Commands');
+        expect(formatted).toContain('tier0: pnpm lint && pnpm typecheck');
+        expect(formatted).toContain('tier1: pnpm test');
+    });
+    it('includes reference file content', () => {
+        const pack = buildContextPack({
+            repoRoot: REPO_ROOT,
+            targetRoot: 'apps/tactical-grid',
+            config: {},
+            references: [{ pattern: 'RNG pattern' }]
+        });
+        const formatted = formatContextPackForPrompt(pack);
+        expect(formatted).toContain('Reference Files');
+        expect(formatted).toContain('nextInt');
+    });
+});
+describe('estimatePackTokens', () => {
+    it('estimates token count based on character length', () => {
+        const pack = buildContextPack({
+            repoRoot: REPO_ROOT,
+            targetRoot: 'apps/tactical-grid',
+            config: {
+                verification: { tier0: ['pnpm lint'] }
+            }
+        });
+        const tokens = estimatePackTokens(pack);
+        expect(tokens).toBeGreaterThan(0);
+        expect(tokens).toBeLessThan(10000); // Sanity check
+    });
+});