feat: detect agent config dirs via WSL env vars

Resolve CLAUDE_CONFIG_DIR and CODEX_HOME from WSL environment at
startup (parallel with $HOME resolution). Adapters use detected paths
with fallback to defaults (~/.claude, ~/.codex).

- log-adapters.ts: AgentEnvContext interface, Claude/Codex adapters
  accept env context in getLogDirs()
- cost-tracker.ts: resolves CLAUDE_CONFIG_DIR + CODEX_HOME via wslExec,
  passes to adapters during discovery
- skill-scanner.ts: resolveCodexHome() uses $CODEX_HOME for skills path
- 4 new tests for env var override paths
- Comments documenting Goose, OpenCode, Gemini CLI, Amazon Q env vars
  for future adapter development

Co-Authored-By: Rooty

Author: Wintersta7e

src/main/cost-tracker.test.ts

@@ -87,6 +87,9 @@ function makeRoutingMock(overrides?: {
       const cmd = Array.isArray(args) ? args.join(' ') : ''
       if (cmd.includes('echo "$HOME"')) {
         cb(null, `${home}\n`, '')
+      } else if (cmd.includes('CLAUDE_CONFIG_DIR') || cmd.includes('CODEX_HOME')) {
+        // Agent env var resolution — return empty (use defaults)
+        cb(null, '\n', '')
       } else if (cmd.includes('find ')) {
         cb(null, findResult, '')
       } else if (cmd.includes('head ')) {

src/main/cost-tracker.ts

@@ -10,7 +10,7 @@ import type { BrowserWindow } from 'electron'
 import { execFile } from 'child_process'
 import { toWslPath } from './wsl-utils'
 import { createLogger } from './logger'
-import type { LogAdapter, TokenUsage } from './log-adapters'
+import type { AgentEnvContext, LogAdapter, TokenUsage } from './log-adapters'
 import { ZERO_USAGE } from './log-adapters'
 
 const log = createLogger('cost-tracker')
@@ -106,18 +106,50 @@ export function createCostTracker(mainWindow: BrowserWindow, adapters: LogAdapte
       return ''
     })
 
+  // Resolve agent config env vars from WSL (CLAUDE_CONFIG_DIR, CODEX_HOME).
+  // These override the default ~/.claude and ~/.codex base paths.
+  // Resolved in parallel with $HOME since they're independent.
+  let cachedEnv: AgentEnvContext | null = null
+  const envReady: Promise<AgentEnvContext> = Promise.all([
+    // eslint-disable-next-line no-template-curly-in-string -- bash variable expansion, not JS
+    wslExec('echo "${CLAUDE_CONFIG_DIR:-}"')
+      .then((o) => o.trim())
+      .catch(() => ''),
+    // eslint-disable-next-line no-template-curly-in-string -- bash variable expansion, not JS
+    wslExec('echo "${CODEX_HOME:-}"')
+      .then((o) => o.trim())
+      .catch(() => ''),
+  ])
+    .then(([rawClaude, rawCodex]) => {
+      const claudeConfigDir = rawClaude || undefined
+      const codexHome = rawCodex || undefined
+      const env: AgentEnvContext = { claudeConfigDir, codexHome }
+      cachedEnv = env
+      log.info('Resolved WSL agent env vars', { claudeConfigDir, codexHome })
+      return env
+    })
+    .catch((err) => {
+      log.warn('Failed to resolve WSL agent env vars — using defaults', {
+        err: String(err),
+      })
+      const env: AgentEnvContext = {}
+      cachedEnv = env
+      return env
+    })
+
   // ── Discovery ───────────────────────────────────────────────────
 
   function startDiscovery(session: BoundSession): void {
-    const rawDirs = session.adapter.getLogDirs(session.projectPath)
     const pattern = session.adapter.getFilePattern()
 
-    // Use cached $HOME if available; otherwise wait for the initial resolution.
+    // Use cached values if available; otherwise wait for initial resolution.
     const homePromise = cachedHome !== null ? Promise.resolve(cachedHome) : homeReady
+    const envPromise = cachedEnv !== null ? Promise.resolve(cachedEnv) : envReady
 
-    homePromise
-      .then((home) => {
+    Promise.all([homePromise, envPromise])
+      .then(([home, env]) => {
         if (!sessions.has(session.sessionId)) return
+        const rawDirs = session.adapter.getLogDirs(session.projectPath, env)
         const dirs = home
           ? rawDirs.map((d) => (d.startsWith('~') ? home + d.slice(1) : d))
           : rawDirs.filter((d) => !d.startsWith('~'))
@@ -130,7 +162,7 @@ export function createCostTracker(mainWindow: BrowserWindow, adapters: LogAdapte
         runDiscoveryLoop(session, dirs, pattern)
       })
       .catch(() => {
-        /* homeReady never rejects (has .catch), but guard defensively */
+        /* homeReady/envReady never reject (have .catch), but guard defensively */
       })
   }
 

src/main/log-adapters.test.ts

@@ -80,6 +80,26 @@ describe('ClaudeAdapter', () => {
     expect(first).toMatch(/~\/\.claude\/projects\/-home-rooty-my-project\/$/)
   })
 
+  it('getLogDirs uses CLAUDE_CONFIG_DIR from env context', () => {
+    const dirs = adapter.getLogDirs('/home/rooty/my-project', {
+      claudeConfigDir: '/custom/claude-config',
+    })
+    expect(dirs).toHaveLength(1)
+    const first = dirs[0]
+    if (!first) throw new Error('Expected first dir')
+    expect(first).toMatch(/^\/custom\/claude-config\/projects\/-home-rooty-my-project\/$/)
+    // Should NOT contain tilde
+    expect(first).not.toContain('~')
+  })
+
+  it('getLogDirs falls back to ~/.claude when env context has no claudeConfigDir', () => {
+    const dirs = adapter.getLogDirs('/home/rooty/my-project', {})
+    expect(dirs).toHaveLength(1)
+    const first = dirs[0]
+    if (!first) throw new Error('Expected first dir')
+    expect(first).toMatch(/^~\/\.claude\/projects\//)
+  })
+
   it('getFilePattern returns "*.jsonl"', () => {
     expect(adapter.getFilePattern()).toBe('*.jsonl')
   })
@@ -231,6 +251,24 @@ describe('CodexAdapter', () => {
     expect(dir).toMatch(/\d{4}\/\d{2}\/\d{2}$/)
   })
 
+  it('getLogDirs uses CODEX_HOME from env context', () => {
+    const dirs = adapter.getLogDirs('/home/rooty/any', { codexHome: '/custom/codex' })
+    expect(dirs).toHaveLength(1)
+    const dir = dirs[0]
+    if (!dir) throw new Error('Expected dir')
+    expect(dir).toMatch(/^\/custom\/codex\/sessions\/\d{4}\/\d{2}\/\d{2}$/)
+    // Should NOT contain tilde
+    expect(dir).not.toContain('~')
+  })
+
+  it('getLogDirs falls back to ~/.codex when env context has no codexHome', () => {
+    const dirs = adapter.getLogDirs('/home/rooty/any', {})
+    expect(dirs).toHaveLength(1)
+    const dir = dirs[0]
+    if (!dir) throw new Error('Expected dir')
+    expect(dir).toContain('~/.codex/sessions/')
+  })
+
   it('getFilePattern returns "rollout-*.jsonl"', () => {
     expect(adapter.getFilePattern()).toBe('rollout-*.jsonl')
   })

src/main/log-adapters.ts

@@ -10,6 +10,12 @@ import { createLogger } from './logger'
 
 const log = createLogger('log-adapters')
 
+// Future adapter env vars:
+// Goose: GOOSE_CONFIG_DIR (config), data at ~/.local/share/goose/
+// OpenCode: OPENCODE_DATA_DIR (data), OPENCODE_CONFIG_DIR (config)
+// Gemini CLI: no env var yet (requested: github.com/google-gemini/gemini-cli/issues/2815)
+// Amazon Q: no env var, free service (no cost tracking needed)
+
 /** Track which schema warnings have already been emitted (avoid flooding). */
 const warnedSchemas = new Set<string>()
 
@@ -34,10 +40,22 @@ export const ZERO_USAGE: Readonly<TokenUsage> = Object.freeze({
   totalCostUsd: 0,
 })
 
+/**
+ * Resolved WSL environment variables for agent config directories.
+ * These are read from the WSL environment (via wslExec), NOT from Node's process.env.
+ * Each field is the resolved absolute path, or undefined if the env var is unset.
+ */
+export interface AgentEnvContext {
+  /** $CLAUDE_CONFIG_DIR — overrides ~/.claude */
+  claudeConfigDir?: string | undefined
+  /** $CODEX_HOME — overrides ~/.codex */
+  codexHome?: string | undefined
+}
+
 export interface LogAdapter {
   agent: string
   /** Return candidate directories (tilde-prefixed) to search for log files. */
-  getLogDirs(projectPath: string): string[]
+  getLogDirs(projectPath: string, env?: AgentEnvContext): string[]
   /** Glob pattern for log files within the dir. */
   getFilePattern(): string
   /**
@@ -115,14 +133,15 @@ export function createClaudeAdapter(): LogAdapter {
   return {
     agent: 'claude-code',
 
-    getLogDirs(projectPath: string): string[] {
+    getLogDirs(projectPath: string, env?: AgentEnvContext): string[] {
       // Replace every `/` with `-` to match Claude's path-slug convention.
       const pathSlug = projectPath.replace(/\//g, '-')
       // JSONL files live directly in the project slug directory (no sessions/ subdir).
       // Only search the project-specific directory — the old fallback
       // `~/.claude/projects/` recursively scanned ALL projects, returning hundreds
       // of candidates and causing discovery timeouts with multiple concurrent sessions.
-      return [`~/.claude/projects/${pathSlug}/`]
+      const claudeHome = env?.claudeConfigDir ?? '~/.claude'
+      return [`${claudeHome}/projects/${pathSlug}/`]
     },
 
     getFilePattern(): string {
@@ -223,8 +242,9 @@ export function createCodexAdapter(): LogAdapter {
   return {
     agent: 'codex',
 
-    getLogDirs(_projectPath: string): string[] {
-      return [`~/.codex/sessions/${todayDateDir()}`]
+    getLogDirs(_projectPath: string, env?: AgentEnvContext): string[] {
+      const codexHome = env?.codexHome ?? '~/.codex'
+      return [`${codexHome}/sessions/${todayDateDir()}`]
     },
 
     getFilePattern(): string {

src/main/skill-scanner.ts

@@ -42,6 +42,7 @@ interface SkillCache {
 
 let globalCache: SkillCache | null = null
 const cachedHomePaths = new Map<string, string>()
+const cachedCodexHomes = new Map<string, string>()
 const projectCache = new Map<string, SkillCache>()
 const inFlight = new Map<string, Promise<SkillCache>>()
 
@@ -86,6 +87,18 @@ async function resolveHomePath(distro: string): Promise<string | null> {
   return home
 }
 
+// ── Cached $CODEX_HOME resolution ────────────────────────────────
+
+async function resolveCodexHome(distro: string, homePath: string): Promise<string> {
+  const cached = cachedCodexHomes.get(distro)
+  if (cached) return cached
+  // eslint-disable-next-line no-template-curly-in-string -- bash variable expansion, not JS
+  const output = await wslExec('echo "${CODEX_HOME:-}"', distro)
+  const resolved = output?.trim() || `${homePath}/.codex`
+  cachedCodexHomes.set(distro, resolved)
+  return resolved
+}
+
 // ── Frontmatter parsing ───────────────────────────────────────────
 
 export function parseFrontmatter(content: string, dirName: string): ParsedFrontmatter | null {
@@ -270,7 +283,8 @@ export async function getGlobalSkills(
     return { skills: [], skipped: 0, timestamp: Date.now() }
   }
 
-  const globalSkillsPath = `${homePath}/.codex/skills`
+  const codexHome = await resolveCodexHome(resolvedDistro, homePath)
+  const globalSkillsPath = `${codexHome}/skills`
   const key = cacheKey('global', globalSkillsPath, resolvedDistro)
 
   // Deduplicate in-flight requests
@@ -417,6 +431,7 @@ export function invalidateProjectCache(projectPath: string): void {
 export function invalidateAllCaches(): void {
   globalCache = null
   cachedHomePaths.clear()
+  cachedCodexHomes.clear()
   projectCache.clear()
   inFlight.clear()
 }