fix(omp): discover sub-agent sessions nested inside session subdirectories

OMP stores sub-agent JSONL files one level deeper than the project dir:
  ~/.omp/agent/sessions/<project>/<session-id>/<agent-name>.jsonl

The previous flat readdir scan only found files directly inside the
project dir, missing all sub-agent sessions entirely.

- Extract collectJsonlFromDir helper that recurses one level into
  subdirectories within each project dir
- Extend collectDiscoverySnapshot to also record mtime of sub-session
  subdirectories (adding files inside a subdir does not bump the parent
  dir mtime, so cache invalidation would otherwise never trigger)
- Add test covering sub-agent session discovery

Author: cgrossde

src/providers/pi.ts

@@ -88,6 +88,23 @@ async function collectDiscoverySnapshot(sessionsDir: string): Promise<DiscoveryS
     const dirStat = await stat(dirPath).catch(() => null)
     if (!dirStat?.isDirectory()) continue
     snapshot.push({ path: dirPath, mtimeMs: dirStat.mtimeMs })
+
+    // Sub-agent sessions land in <project-dir>/<session-id>/ subdirectories.
+    // Their mtimes must be tracked separately — adding files inside a subdir
+    // does not bump the parent project dir's mtime.
+    let subEntries: string[]
+    try {
+      subEntries = await readdir(dirPath)
+    } catch {
+      continue
+    }
+    for (const subName of subEntries) {
+      const subPath = join(dirPath, subName)
+      const subStat = await stat(subPath).catch(() => null)
+      if (subStat?.isDirectory()) {
+        snapshot.push({ path: subPath, mtimeMs: subStat.mtimeMs })
+      }
+    }
   }
 
   return snapshot
@@ -112,39 +129,58 @@ async function discoverSessionsInDir(sessionsDir: string, providerName: string):
     const dirStat = await stat(dirPath).catch(() => null)
     if (!dirStat?.isDirectory()) continue
 
-    let files: string[]
-    try {
-      files = await readdir(dirPath)
-    } catch {
-      continue
-    }
-
-    for (const file of files) {
-      if (!file.endsWith('.jsonl')) continue
-      const filePath = join(dirPath, file)
-      const fileStat = await stat(filePath).catch(() => null)
-      if (!fileStat?.isFile()) continue
-
-      const first = await readFirstEntry(filePath)
-      if (!first || first.type !== 'session') continue
-
-      const cwd = first.cwd ?? dirName
-      sources.push({
-        path: filePath,
-        project: basename(cwd),
-        provider: providerName,
-        fingerprintPath: filePath,
-        cacheStrategy: 'append-jsonl',
-        progressLabel: basename(filePath),
-        parserVersion: `${providerName}:v1`,
-      })
-    }
+    await collectJsonlFromDir(dirPath, dirName, providerName, sources)
   }
 
   await saveDiscoveryCache(providerName, sessionsDir, snapshot, sources)
   return sources
 }
 
+// Collects session sources from dirPath and one level of subdirectories.
+// Sub-agent sessions land in <project-dir>/<parent-session-id>/<agent-name>.jsonl,
+// so we must recurse one level deeper than the project directory.
+async function collectJsonlFromDir(
+  dirPath: string,
+  projectDirName: string,
+  providerName: string,
+  sources: SessionSource[],
+): Promise<void> {
+  let entries: string[]
+  try {
+    entries = await readdir(dirPath)
+  } catch {
+    return
+  }
+
+  for (const entry of entries) {
+    const entryPath = join(dirPath, entry)
+    const entryStat = await stat(entryPath).catch(() => null)
+    if (!entryStat) continue
+
+    if (entryStat.isDirectory()) {
+      // Sub-agent session dir: recurse one level, but don't go deeper
+      await collectJsonlFromDir(entryPath, projectDirName, providerName, sources)
+      continue
+    }
+
+    if (!entryStat.isFile() || !entry.endsWith('.jsonl')) continue
+
+    const first = await readFirstEntry(entryPath)
+    if (!first || first.type !== 'session') continue
+
+    const cwd = first.cwd ?? projectDirName
+    sources.push({
+      path: entryPath,
+      project: basename(cwd),
+      provider: providerName,
+      fingerprintPath: entryPath,
+      cacheStrategy: 'append-jsonl',
+      progressLabel: basename(entryPath),
+      parserVersion: `${providerName}:v1`,
+    })
+  }
+}
+
 function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser {
   return {
     async *parse(): AsyncGenerator<ParsedProviderCall> {
@@ -188,7 +224,7 @@ function createParser(source: SessionSource, seenKeys: Set<string>): SessionPars
 
         const model = msg.model ?? 'gpt-5'
         const responseId = msg.responseId ?? ''
-        const dedupKey = `pi:${source.path}:${responseId || entry.id || entry.timestamp || String(lineIdx)}`
+        const dedupKey = `${source.provider}:${source.path}:${responseId || entry.id || entry.timestamp || String(lineIdx)}`
 
         if (seenKeys.has(dedupKey)) continue
         seenKeys.add(dedupKey)
@@ -289,4 +325,4 @@ export function createOmpProvider(sessionsDir?: string): Provider {
   }
 }
 
-export const omp = createOmpProvider()
+export const omp = createOmpProvider()

tests/providers/omp.test.ts

@@ -126,6 +126,35 @@ describe('omp provider - session discovery', () => {
     const sessions = await provider.discoverSessions()
     expect(sessions).toEqual([])
   })
+  it('discovers sub-agent sessions nested inside session subdirectory', async () => {
+    const projectDir = join(tmpDir, '--Users-test-myproject--')
+    const parentFile = '2026-04-21T10-00-00-000Z_abc123'
+
+    // Main session at project-dir level
+    await writeSession(projectDir, `${parentFile}.jsonl`, [
+      sessionMeta({ id: 'main-session', cwd: '/Users/test/myproject' }),
+      assistantMessage({}),
+    ])
+
+    // Sub-agent sessions inside <session-id>/ subdirectory
+    const subDir = join(projectDir, parentFile)
+    await writeSession(subDir, '0-SubAgent.jsonl', [
+      sessionMeta({ id: 'sub-agent-0', cwd: '/Users/test/myproject' }),
+      assistantMessage({ input: 500, output: 100 }),
+    ])
+    await writeSession(subDir, '1-SubAgent.jsonl', [
+      sessionMeta({ id: 'sub-agent-1', cwd: '/Users/test/myproject' }),
+      assistantMessage({ input: 600, output: 120 }),
+    ])
+
+    const provider = createOmpProvider(tmpDir)
+    const sessions = await provider.discoverSessions()
+
+    expect(sessions).toHaveLength(3)
+    expect(sessions.every(s => s.provider === 'omp')).toBe(true)
+    expect(sessions.every(s => s.project === 'myproject')).toBe(true)
+  })
+
 })
 
 describe('omp provider - JSONL parsing', () => {
@@ -164,7 +193,7 @@ describe('omp provider - JSONL parsing', () => {
     expect(call.sessionId).toBe('sess-omp-1')
     expect(call.userMessage).toBe('write a test')
     expect(call.timestamp).toBe('2026-04-14T10:00:30.000Z')
-    expect(call.deduplicationKey).toContain('pi:')
+    expect(call.deduplicationKey).toContain('omp:')
     expect(call.deduplicationKey).toContain('resp-omp-1')
   })
 
@@ -183,7 +212,7 @@ describe('omp provider - JSONL parsing', () => {
     }
 
     // cost must be calculated by codeburn, not taken from usage.cost (which is zeroed in fixture)
-    expect(calls[0]!.costUSD).toBeGreaterThanOrEqual(0)
+    expect(calls[0]!.costUSD).toBeGreaterThan(0)
   })
 
   it('collects tool names from toolCall content items', async () => {