@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/adapters/GeminiCliAdapter.ts

@@ -10,30 +10,30 @@
  * 5. Extracting summary from the most recent user message in the session JSON
  */
 
-import * as crypto from 'crypto';
-import * as fs from 'fs';
-import * as path from 'path';
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
 import type {
-    AgentAdapter,
-    AgentInfo,
-    ProcessInfo,
-    ConversationMessage,
-    SessionSummary,
-    ListSessionsOptions,
-    AgentDetectionContext,
-} from './AgentAdapter.js';
-import { AgentStatus } from './AgentAdapter.js';
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "./AgentAdapter.js";
+import { AgentStatus } from "./AgentAdapter.js";
 import {
-    captureProcessSnapshot,
-    executableBasename,
-    filterByProcessNames,
-    findWrapperProcess,
-    findWrapperProcessPids,
-} from '../utils/process.js';
-import { isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
-import type { SessionFile } from '../utils/session.js';
-import { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';
-import { AgentRegistry, type RegistryEntry } from '../utils/AgentRegistry.js';
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+  findWrapperProcess,
+  findWrapperProcessPids,
+} from "../utils/process.js";
+import { isDirectory, safeReadFile, safeReaddir, safeStat } from "../utils/session.js";
+import type { SessionFile } from "../utils/session.js";
+import { matchProcessesToSessions, generateAgentName } from "../utils/matching.js";
+import { AgentRegistry, type RegistryEntry } from "../utils/AgentRegistry.js";
 
 /**
  * A single Gemini CLI message content part. Mirrors the `{text?: string}`
@@ -43,659 +43,657 @@ import { AgentRegistry, type RegistryEntry } from '../utils/AgentRegistry.js';
  * `resolveContent` since the adapter only surfaces human-readable text.
  */
 interface GeminiContentPart {
-    text?: string;
-    [key: string]: unknown;
+  text?: string;
+  [key: string]: unknown;
 }
 
 type GeminiMessageContent = string | GeminiContentPart[];
 
 interface GeminiMessageEntry {
-    id?: string;
-    timestamp?: string;
-    type?: string;
-    /**
-     * Gemini CLI stores two different content shapes depending on the
-     * message origin:
-     * - `type: "user"` messages carry the raw Part[] from userContent.parts
-     *   (e.g. `[{ text: "hello" }]`).
-     * - `type: "gemini"` (assistant) messages carry a pre-joined string
-     *   built from `consolidatedParts.filter(p => p.text).join('').trim()`.
-     * Both forms must be normalized via resolveContent before any string
-     * operation is applied.
-     */
-    content?: GeminiMessageContent;
-    displayContent?: GeminiMessageContent;
+  id?: string;
+  timestamp?: string;
+  type?: string;
+  /**
+   * Gemini CLI stores two different content shapes depending on the
+   * message origin:
+   * - `type: "user"` messages carry the raw Part[] from userContent.parts
+   *   (e.g. `[{ text: "hello" }]`).
+   * - `type: "gemini"` (assistant) messages carry a pre-joined string
+   *   built from `consolidatedParts.filter(p => p.text).join('').trim()`.
+   * Both forms must be normalized via resolveContent before any string
+   * operation is applied.
+   */
+  content?: GeminiMessageContent;
+  displayContent?: GeminiMessageContent;
 }
 
 interface GeminiSessionFile {
-    sessionId?: string;
-    projectHash?: string;
-    startTime?: string;
-    lastUpdated?: string;
-    messages?: GeminiMessageEntry[];
-    directories?: string[];
-    kind?: string;
+  sessionId?: string;
+  projectHash?: string;
+  startTime?: string;
+  lastUpdated?: string;
+  messages?: GeminiMessageEntry[];
+  directories?: string[];
+  kind?: string;
 }
 
 interface GeminiSession {
-    sessionId: string;
-    projectPath: string;
-    summary: string;
-    sessionStart: Date;
-    lastActive: Date;
-    lastMessageType?: string;
+  sessionId: string;
+  projectPath: string;
+  summary: string;
+  sessionStart: Date;
+  lastActive: Date;
+  lastMessageType?: string;
 }
 
 export class GeminiCliAdapter implements AgentAdapter {
-    readonly type = 'gemini_cli' as const;
-    readonly processNames = ['node'] as const;
-
-    private static readonly IDLE_THRESHOLD_MINUTES = 5;
-    private static readonly SESSION_FILE_PREFIX = 'session-';
-    private static readonly CHATS_DIR_NAME = 'chats';
-    private static readonly TMP_DIR_NAME = 'tmp';
-
-    private geminiTmpDir: string;
-    private registry: AgentRegistry;
-
-    constructor(registry: AgentRegistry = AgentRegistry.default()) {
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-        this.geminiTmpDir = path.join(homeDir, '.gemini', GeminiCliAdapter.TMP_DIR_NAME);
-        this.registry = registry;
+  readonly type = "gemini_cli" as const;
+  readonly processNames = ["node"] as const;
+
+  private static readonly IDLE_THRESHOLD_MINUTES = 5;
+  private static readonly SESSION_FILE_PREFIX = "session-";
+  private static readonly CHATS_DIR_NAME = "chats";
+  private static readonly TMP_DIR_NAME = "tmp";
+
+  private geminiTmpDir: string;
+  private registry: AgentRegistry;
+
+  constructor(registry: AgentRegistry = AgentRegistry.default()) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.geminiTmpDir = path.join(homeDir, ".gemini", GeminiCliAdapter.TMP_DIR_NAME);
+    this.registry = registry;
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return this.isGeminiExecutable(processInfo.command);
+  }
+
+  /**
+   * Detect running Gemini CLI agents.
+   *
+   * Gemini CLI ships as a Node script (`bundle/gemini.js` with shebang
+   * `#!/usr/bin/env node`) — unlike Claude Code (native binary per
+   * platform) or Codex CLI (Node wrapper that execs a native Rust
+   * binary). The primary running process is therefore the Node runtime
+   * itself, and `ps aux` lists it as `node /path/to/gemini ...` with
+   * argv[0] = `node`. We scan the Node process pool via the shared
+   * snapshot and keep only those whose command line references the gemini
+   * executable or script via isGeminiExecutable().
+   */
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
+    const relevant = filterByProcessNames(snapshot, this.processNames);
+    const processes = relevant.filter((process) => this.canHandle(process));
+    if (processes.length === 0) return [];
+
+    const wrapperPids = findWrapperProcessPids(processes);
+    const { cachedAgents, remaining } = this.tryRegistryCache(processes, wrapperPids);
+    if (remaining.length === 0) return this.deduplicateSessionAgents(cachedAgents);
+
+    const candidateProcesses = remaining.filter((proc) => !wrapperPids.has(proc.pid));
+    const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
+
+    const { sessions, contentCache } = this.discoverSessions(candidateProcesses);
+    if (sessions.length === 0) {
+      const processOnlyAgents = candidateProcesses.map((proc) => {
+        const agent = this.mapProcessOnlyAgent(proc);
+        this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+        return agent;
+      });
+
+      return this.deduplicateSessionAgents([...cachedAgents, ...processOnlyAgents]);
     }
 
-    canHandle(processInfo: ProcessInfo): boolean {
-        return this.isGeminiExecutable(processInfo.command);
+    const matches = matchProcessesToSessions(candidateProcesses, sessions);
+    const matchedPids = new Set(matches.map((m) => m.process.pid));
+    const matchedProcesses: ProcessInfo[] = [];
+    const agents: AgentInfo[] = [];
+
+    for (const match of matches) {
+      const cachedContent = contentCache.get(match.session.filePath);
+      const sessionData = this.parseSession(cachedContent, match.session.filePath);
+      if (sessionData) {
+        const agent = this.mapSessionToAgent(sessionData, match.process, match.session.filePath);
+        this.applyWrapperRegistryName(agent, match.process, processes, registryEntriesByPid);
+        agents.push(agent);
+        matchedProcesses.push(match.process);
+      } else {
+        matchedPids.delete(match.process.pid);
+      }
     }
 
-    /**
-     * Detect running Gemini CLI agents.
-     *
-     * Gemini CLI ships as a Node script (`bundle/gemini.js` with shebang
-     * `#!/usr/bin/env node`) — unlike Claude Code (native binary per
-     * platform) or Codex CLI (Node wrapper that execs a native Rust
-     * binary). The primary running process is therefore the Node runtime
-     * itself, and `ps aux` lists it as `node /path/to/gemini ...` with
-     * argv[0] = `node`. We scan the Node process pool via the shared
-     * snapshot and keep only those whose command line references the gemini
-     * executable or script via isGeminiExecutable().
-     */
-    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
-        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
-        const relevant = filterByProcessNames(snapshot, this.processNames);
-        const processes = relevant.filter((process) => this.canHandle(process));
-        if (processes.length === 0) return [];
-
-        const wrapperPids = findWrapperProcessPids(processes);
-        const { cachedAgents, remaining } = this.tryRegistryCache(processes, wrapperPids);
-        if (remaining.length === 0) return this.deduplicateSessionAgents(cachedAgents);
-
-        const candidateProcesses = remaining.filter((proc) => !wrapperPids.has(proc.pid));
-        const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
-
-        const { sessions, contentCache } = this.discoverSessions(candidateProcesses);
-        if (sessions.length === 0) {
-            const processOnlyAgents = candidateProcesses.map((proc) => {
-                const agent = this.mapProcessOnlyAgent(proc);
-                this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
-                return agent;
-            });
-
-            return this.deduplicateSessionAgents([
-                ...cachedAgents,
-                ...processOnlyAgents,
-            ]);
-        }
-
-        const matches = matchProcessesToSessions(candidateProcesses, sessions);
-        const matchedPids = new Set(matches.map((m) => m.process.pid));
-        const matchedProcesses: ProcessInfo[] = [];
-        const agents: AgentInfo[] = [];
-
-        for (const match of matches) {
-            const cachedContent = contentCache.get(match.session.filePath);
-            const sessionData = this.parseSession(cachedContent, match.session.filePath);
-            if (sessionData) {
-                const agent = this.mapSessionToAgent(sessionData, match.process, match.session.filePath);
-                this.applyWrapperRegistryName(agent, match.process, processes, registryEntriesByPid);
-                agents.push(agent);
-                matchedProcesses.push(match.process);
-            } else {
-                matchedPids.delete(match.process.pid);
-            }
-        }
-
-        const matchedWrapperPids = findWrapperProcessPids(candidateProcesses, matchedProcesses);
-        for (const proc of candidateProcesses) {
-            if (!matchedPids.has(proc.pid) && !matchedWrapperPids.has(proc.pid)) {
-                const agent = this.mapProcessOnlyAgent(proc);
-                this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
-                agents.push(agent);
-            }
-        }
-
-        return this.deduplicateSessionAgents([...cachedAgents, ...agents]);
+    const matchedWrapperPids = findWrapperProcessPids(candidateProcesses, matchedProcesses);
+    for (const proc of candidateProcesses) {
+      if (!matchedPids.has(proc.pid) && !matchedWrapperPids.has(proc.pid)) {
+        const agent = this.mapProcessOnlyAgent(proc);
+        this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+        agents.push(agent);
+      }
     }
 
-    private applyWrapperRegistryName(
-        agent: AgentInfo,
-        processInfo: ProcessInfo,
-        processes: ProcessInfo[],
-        registryEntriesByPid: Map<number, RegistryEntry>,
-    ): void {
-        const wrapper = findWrapperProcess(processes, processInfo);
-        const wrapperEntry = wrapper ? registryEntriesByPid.get(wrapper.pid) : undefined;
-        if (wrapperEntry?.type === this.type) {
-            agent.name = wrapperEntry.name;
-        }
+    return this.deduplicateSessionAgents([...cachedAgents, ...agents]);
+  }
+
+  private applyWrapperRegistryName(
+    agent: AgentInfo,
+    processInfo: ProcessInfo,
+    processes: ProcessInfo[],
+    registryEntriesByPid: Map<number, RegistryEntry>,
+  ): void {
+    const wrapper = findWrapperProcess(processes, processInfo);
+    const wrapperEntry = wrapper ? registryEntriesByPid.get(wrapper.pid) : undefined;
+    if (wrapperEntry?.type === this.type) {
+      agent.name = wrapperEntry.name;
     }
-
-    private deduplicateSessionAgents(agents: AgentInfo[]): AgentInfo[] {
-        const bySession = new Map<string, AgentInfo>();
-        const result: AgentInfo[] = [];
-
-        for (const agent of agents) {
-            const sessionKey = this.sessionDeduplicationKey(agent);
-            if (!sessionKey) {
-                result.push(agent);
-                continue;
-            }
-
-            const existing = bySession.get(sessionKey);
-            if (!existing) {
-                bySession.set(sessionKey, agent);
-                result.push(agent);
-                continue;
-            }
-
-            if (agent.pid > existing.pid) {
-                bySession.set(sessionKey, agent);
-                const index = result.indexOf(existing);
-                if (index >= 0) result[index] = agent;
-            }
-        }
-
-        return result;
-    }
-
-    private sessionDeduplicationKey(agent: AgentInfo): string | null {
-        if (agent.sessionFilePath) return `file:${agent.sessionFilePath}`;
-        if (agent.sessionId && !agent.sessionId.startsWith('pid-')) {
-            return `session:${agent.sessionId}`;
-        }
-        return null;
+  }
+
+  private deduplicateSessionAgents(agents: AgentInfo[]): AgentInfo[] {
+    const bySession = new Map<string, AgentInfo>();
+    const result: AgentInfo[] = [];
+
+    for (const agent of agents) {
+      const sessionKey = this.sessionDeduplicationKey(agent);
+      if (!sessionKey) {
+        result.push(agent);
+        continue;
+      }
+
+      const existing = bySession.get(sessionKey);
+      if (!existing) {
+        bySession.set(sessionKey, agent);
+        result.push(agent);
+        continue;
+      }
+
+      if (agent.pid > existing.pid) {
+        bySession.set(sessionKey, agent);
+        const index = result.indexOf(existing);
+        if (index >= 0) result[index] = agent;
+      }
     }
 
-    private tryRegistryCache(processes: ProcessInfo[], wrapperPids: Set<number>): {
-        cachedAgents: AgentInfo[];
-        remaining: ProcessInfo[];
-    } {
-        const cachedAgents: AgentInfo[] = [];
-        const remaining: ProcessInfo[] = [];
-        const byPid = new Map(this.registry.list().map((e) => [e.pid, e]));
-
-        for (const proc of processes) {
-            const entry = byPid.get(proc.pid);
-            if (
-                wrapperPids.has(proc.pid) ||
-                !entry ||
-                entry.type !== this.type ||
-                !entry.sessionFilePath ||
-                !fs.existsSync(entry.sessionFilePath)
-            ) {
-                remaining.push(proc);
-                continue;
-            }
-
-            const content = safeReadFile(entry.sessionFilePath);
-            const sessionData = this.parseSession(content, entry.sessionFilePath);
-            if (!sessionData) {
-                remaining.push(proc);
-                continue;
-            }
-
-            cachedAgents.push(this.mapSessionToAgent(sessionData, proc, entry.sessionFilePath));
-        }
+    return result;
+  }
 
-        return { cachedAgents, remaining };
+  private sessionDeduplicationKey(agent: AgentInfo): string | null {
+    if (agent.sessionFilePath) return `file:${agent.sessionFilePath}`;
+    if (agent.sessionId && !agent.sessionId.startsWith("pid-")) {
+      return `session:${agent.sessionId}`;
     }
-
-    /**
-     * Discover session files for the given processes.
-     *
-     * Gemini CLI writes sessions to ~/.gemini/tmp/<shortId>/chats/session-*.json
-     * where <shortId> is opaque (managed by a project registry). We scan every
-     * shortId directory and filter by matching session.projectHash against
-     * sha256(process.cwd) to bind each session to a candidate process CWD.
-     */
-    private discoverSessions(processes: ProcessInfo[]): {
-        sessions: SessionFile[];
-        contentCache: Map<string, string>;
-    } {
-        const empty = { sessions: [] as SessionFile[], contentCache: new Map<string, string>() };
-        if (!fs.existsSync(this.geminiTmpDir)) return empty;
-
-        const cwdHashMap = this.buildCwdHashMap(processes);
-        if (cwdHashMap.size === 0) return empty;
-
-        const contentCache = new Map<string, string>();
-        const sessions: SessionFile[] = [];
-
-        let shortIdEntries: string[];
-        try {
-            shortIdEntries = fs.readdirSync(this.geminiTmpDir);
-        } catch {
-            return empty;
-        }
-
-        for (const shortId of shortIdEntries) {
-            const chatsDir = path.join(this.geminiTmpDir, shortId, GeminiCliAdapter.CHATS_DIR_NAME);
-            try {
-                if (!fs.statSync(chatsDir).isDirectory()) continue;
-            } catch {
-                continue;
-            }
-
-            let chatFiles: string[];
-            try {
-                chatFiles = fs.readdirSync(chatsDir);
-            } catch {
-                continue;
-            }
-
-            for (const fileName of chatFiles) {
-                if (!fileName.startsWith(GeminiCliAdapter.SESSION_FILE_PREFIX) || !fileName.endsWith('.json')) {
-                    continue;
-                }
-
-                const filePath = path.join(chatsDir, fileName);
-
-                let content: string;
-                try {
-                    content = fs.readFileSync(filePath, 'utf-8');
-                } catch {
-                    continue;
-                }
-
-                let parsed: GeminiSessionFile;
-                try {
-                    parsed = JSON.parse(content);
-                } catch {
-                    continue;
-                }
-
-                if (!parsed.projectHash) continue;
-                const resolvedCwd = cwdHashMap.get(parsed.projectHash);
-                if (!resolvedCwd) continue;
-
-                let birthtimeMs = 0;
-                try {
-                    birthtimeMs = fs.statSync(filePath).birthtimeMs;
-                } catch {
-                    continue;
-                }
-
-                const sessionId =
-                    parsed.sessionId || fileName.replace(/\.json$/, '');
-
-                contentCache.set(filePath, content);
-                sessions.push({
-                    sessionId,
-                    filePath,
-                    projectDir: chatsDir,
-                    birthtimeMs,
-                    resolvedCwd,
-                });
-            }
-        }
-
-        return { sessions, contentCache };
+    return null;
+  }
+
+  private tryRegistryCache(
+    processes: ProcessInfo[],
+    wrapperPids: Set<number>,
+  ): {
+    cachedAgents: AgentInfo[];
+    remaining: ProcessInfo[];
+  } {
+    const cachedAgents: AgentInfo[] = [];
+    const remaining: ProcessInfo[] = [];
+    const byPid = new Map(this.registry.list().map((e) => [e.pid, e]));
+
+    for (const proc of processes) {
+      const entry = byPid.get(proc.pid);
+      if (
+        wrapperPids.has(proc.pid) ||
+        !entry ||
+        entry.type !== this.type ||
+        !entry.sessionFilePath ||
+        !fs.existsSync(entry.sessionFilePath)
+      ) {
+        remaining.push(proc);
+        continue;
+      }
+
+      const content = safeReadFile(entry.sessionFilePath);
+      const sessionData = this.parseSession(content, entry.sessionFilePath);
+      if (!sessionData) {
+        remaining.push(proc);
+        continue;
+      }
+
+      cachedAgents.push(this.mapSessionToAgent(sessionData, proc, entry.sessionFilePath));
     }
 
-    private buildCwdHashMap(processes: ProcessInfo[]): Map<string, string> {
-        const map = new Map<string, string>();
-        for (const proc of processes) {
-            if (!proc.cwd) continue;
-            // Gemini CLI resolves its project root by walking up from the
-            // startup directory looking for a `.git` boundary marker. A
-            // session's projectHash therefore tracks that ancestor rather
-            // than the process' actual CWD. Enumerate every ancestor as a
-            // candidate so subdirectory invocations still line up with the
-            // session the Gemini process wrote.
-            for (const candidate of this.candidateProjectRoots(proc.cwd)) {
-                if (!map.has(this.hashProjectRoot(candidate))) {
-                    map.set(this.hashProjectRoot(candidate), proc.cwd);
-                }
-            }
-        }
-        return map;
+    return { cachedAgents, remaining };
+  }
+
+  /**
+   * Discover session files for the given processes.
+   *
+   * Gemini CLI writes sessions to ~/.gemini/tmp/<shortId>/chats/session-*.json
+   * where <shortId> is opaque (managed by a project registry). We scan every
+   * shortId directory and filter by matching session.projectHash against
+   * sha256(process.cwd) to bind each session to a candidate process CWD.
+   */
+  private discoverSessions(processes: ProcessInfo[]): {
+    sessions: SessionFile[];
+    contentCache: Map<string, string>;
+  } {
+    const empty = { sessions: [] as SessionFile[], contentCache: new Map<string, string>() };
+    if (!fs.existsSync(this.geminiTmpDir)) return empty;
+
+    const cwdHashMap = this.buildCwdHashMap(processes);
+    if (cwdHashMap.size === 0) return empty;
+
+    const contentCache = new Map<string, string>();
+    const sessions: SessionFile[] = [];
+
+    let shortIdEntries: string[];
+    try {
+      shortIdEntries = fs.readdirSync(this.geminiTmpDir);
+    } catch {
+      return empty;
     }
 
-    private candidateProjectRoots(cwd: string): string[] {
-        const roots: string[] = [];
-        let current = path.resolve(cwd);
-        let parent = path.dirname(current);
-        while (parent !== current) {
-            roots.push(current);
-            current = parent;
-            parent = path.dirname(current);
+    for (const shortId of shortIdEntries) {
+      const chatsDir = path.join(this.geminiTmpDir, shortId, GeminiCliAdapter.CHATS_DIR_NAME);
+      try {
+        if (!fs.statSync(chatsDir).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+
+      let chatFiles: string[];
+      try {
+        chatFiles = fs.readdirSync(chatsDir);
+      } catch {
+        continue;
+      }
+
+      for (const fileName of chatFiles) {
+        if (
+          !fileName.startsWith(GeminiCliAdapter.SESSION_FILE_PREFIX) ||
+          !fileName.endsWith(".json")
+        ) {
+          continue;
         }
-        roots.push(current);
-        return roots;
-    }
 
-    private hashProjectRoot(projectRoot: string): string {
-        return crypto.createHash('sha256').update(projectRoot).digest('hex');
-    }
+        const filePath = path.join(chatsDir, fileName);
 
-    /**
-     * Parse session file content into GeminiSession.
-     * Uses cached content if available, otherwise reads from disk.
-     */
-    private parseSession(cachedContent: string | undefined, filePath: string): GeminiSession | null {
         let content: string;
-        if (cachedContent !== undefined) {
-            content = cachedContent;
-        } else {
-            try {
-                content = fs.readFileSync(filePath, 'utf-8');
-            } catch {
-                return null;
-            }
+        try {
+          content = fs.readFileSync(filePath, "utf-8");
+        } catch {
+          continue;
         }
 
         let parsed: GeminiSessionFile;
         try {
-            parsed = JSON.parse(content);
+          parsed = JSON.parse(content);
         } catch {
-            return null;
+          continue;
         }
 
-        if (!parsed.sessionId) return null;
+        if (!parsed.projectHash) continue;
+        const resolvedCwd = cwdHashMap.get(parsed.projectHash);
+        if (!resolvedCwd) continue;
 
-        const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
-        const lastEntry = messages.length > 0 ? messages[messages.length - 1] : undefined;
-
-        let mtime: Date | null = null;
+        let birthtimeMs = 0;
         try {
-            mtime = fs.statSync(filePath).mtime;
+          birthtimeMs = fs.statSync(filePath).birthtimeMs;
         } catch {
-            mtime = null;
+          continue;
         }
 
-        const lastActive =
-            this.parseTimestamp(parsed.lastUpdated) ||
-            this.parseTimestamp(lastEntry?.timestamp) ||
-            mtime ||
-            new Date();
-
-        const sessionStart =
-            this.parseTimestamp(parsed.startTime) || lastActive;
-
-        const projectPath =
-            Array.isArray(parsed.directories) && parsed.directories.length > 0
-                ? parsed.directories[0]
-                : '';
-
-        return {
-            sessionId: parsed.sessionId,
-            projectPath,
-            summary: this.extractSummary(messages),
-            sessionStart,
-            lastActive,
-            lastMessageType: lastEntry?.type,
-        };
+        const sessionId = parsed.sessionId || fileName.replace(/\.json$/, "");
+
+        contentCache.set(filePath, content);
+        sessions.push({
+          sessionId,
+          filePath,
+          projectDir: chatsDir,
+          birthtimeMs,
+          resolvedCwd,
+        });
+      }
     }
 
-    private mapSessionToAgent(session: GeminiSession, processInfo: ProcessInfo, filePath: string): AgentInfo {
-        const projectPath = session.projectPath || processInfo.cwd || '';
-        return {
-            name: generateAgentName(projectPath, processInfo.pid),
-            type: this.type,
-            status: this.determineStatus(session),
-            summary: session.summary || 'Gemini CLI session active',
-            pid: processInfo.pid,
-            projectPath,
-            sessionId: session.sessionId,
-            lastActive: session.lastActive,
-            sessionFilePath: filePath,
-        };
+    return { sessions, contentCache };
+  }
+
+  private buildCwdHashMap(processes: ProcessInfo[]): Map<string, string> {
+    const map = new Map<string, string>();
+    for (const proc of processes) {
+      if (!proc.cwd) continue;
+      // Gemini CLI resolves its project root by walking up from the
+      // startup directory looking for a `.git` boundary marker. A
+      // session's projectHash therefore tracks that ancestor rather
+      // than the process' actual CWD. Enumerate every ancestor as a
+      // candidate so subdirectory invocations still line up with the
+      // session the Gemini process wrote.
+      for (const candidate of this.candidateProjectRoots(proc.cwd)) {
+        if (!map.has(this.hashProjectRoot(candidate))) {
+          map.set(this.hashProjectRoot(candidate), proc.cwd);
+        }
+      }
     }
-
-    private mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
-        return {
-            name: generateAgentName(processInfo.cwd || '', processInfo.pid),
-            type: this.type,
-            status: AgentStatus.RUNNING,
-            summary: 'Gemini CLI process running',
-            pid: processInfo.pid,
-            projectPath: processInfo.cwd || '',
-            sessionId: `pid-${processInfo.pid}`,
-            lastActive: new Date(),
-        };
+    return map;
+  }
+
+  private candidateProjectRoots(cwd: string): string[] {
+    const roots: string[] = [];
+    let current = path.resolve(cwd);
+    let parent = path.dirname(current);
+    while (parent !== current) {
+      roots.push(current);
+      current = parent;
+      parent = path.dirname(current);
     }
-
-    private parseTimestamp(value?: string): Date | null {
-        if (!value) return null;
-        const timestamp = new Date(value);
-        return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+    roots.push(current);
+    return roots;
+  }
+
+  private hashProjectRoot(projectRoot: string): string {
+    return crypto.createHash("sha256").update(projectRoot).digest("hex");
+  }
+
+  /**
+   * Parse session file content into GeminiSession.
+   * Uses cached content if available, otherwise reads from disk.
+   */
+  private parseSession(cachedContent: string | undefined, filePath: string): GeminiSession | null {
+    let content: string;
+    if (cachedContent !== undefined) {
+      content = cachedContent;
+    } else {
+      try {
+        content = fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
     }
 
-    private determineStatus(session: GeminiSession): AgentStatus {
-        const diffMs = Date.now() - session.lastActive.getTime();
-        const diffMinutes = diffMs / 60000;
+    let parsed: GeminiSessionFile;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return null;
+    }
 
-        if (diffMinutes > GeminiCliAdapter.IDLE_THRESHOLD_MINUTES) {
-            return AgentStatus.IDLE;
-        }
+    if (!parsed.sessionId) return null;
 
-        if (session.lastMessageType === 'gemini' || session.lastMessageType === 'assistant') {
-            return AgentStatus.WAITING;
-        }
+    const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+    const lastEntry = messages.length > 0 ? messages[messages.length - 1] : undefined;
 
-        return AgentStatus.RUNNING;
+    let mtime: Date | null = null;
+    try {
+      mtime = fs.statSync(filePath).mtime;
+    } catch {
+      mtime = null;
     }
 
-    private extractSummary(messages: GeminiMessageEntry[]): string {
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const entry = messages[i];
-            if (entry?.type !== 'user') continue;
-            const text = this.messageText(entry).trim();
-            if (text) return this.truncate(text, 120);
-        }
-
-        return 'Gemini CLI session active';
+    const lastActive =
+      this.parseTimestamp(parsed.lastUpdated) ||
+      this.parseTimestamp(lastEntry?.timestamp) ||
+      mtime ||
+      new Date();
+
+    const sessionStart = this.parseTimestamp(parsed.startTime) || lastActive;
+
+    const projectPath =
+      Array.isArray(parsed.directories) && parsed.directories.length > 0
+        ? parsed.directories[0]
+        : "";
+
+    return {
+      sessionId: parsed.sessionId,
+      projectPath,
+      summary: this.extractSummary(messages),
+      sessionStart,
+      lastActive,
+      lastMessageType: lastEntry?.type,
+    };
+  }
+
+  private mapSessionToAgent(
+    session: GeminiSession,
+    processInfo: ProcessInfo,
+    filePath: string,
+  ): AgentInfo {
+    const projectPath = session.projectPath || processInfo.cwd || "";
+    return {
+      name: generateAgentName(projectPath, processInfo.pid),
+      type: this.type,
+      status: this.determineStatus(session),
+      summary: session.summary || "Gemini CLI session active",
+      pid: processInfo.pid,
+      projectPath,
+      sessionId: session.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: filePath,
+    };
+  }
+
+  private mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
+    return {
+      name: generateAgentName(processInfo.cwd || "", processInfo.pid),
+      type: this.type,
+      status: AgentStatus.RUNNING,
+      summary: "Gemini CLI process running",
+      pid: processInfo.pid,
+      projectPath: processInfo.cwd || "",
+      sessionId: `pid-${processInfo.pid}`,
+      lastActive: new Date(),
+    };
+  }
+
+  private parseTimestamp(value?: string): Date | null {
+    if (!value) return null;
+    const timestamp = new Date(value);
+    return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+  }
+
+  private determineStatus(session: GeminiSession): AgentStatus {
+    const diffMs = Date.now() - session.lastActive.getTime();
+    const diffMinutes = diffMs / 60000;
+
+    if (diffMinutes > GeminiCliAdapter.IDLE_THRESHOLD_MINUTES) {
+      return AgentStatus.IDLE;
     }
 
-    /**
-     * Normalize an entry's content/displayContent into a plain string.
-     * Prefers displayContent when both are present (matches Gemini CLI's
-     * own rendering priority for the /chat UI).
-     */
-    private messageText(entry: GeminiMessageEntry): string {
-        const displayText = this.resolveContent(entry.displayContent);
-        if (displayText) return displayText;
-        return this.resolveContent(entry.content);
+    if (session.lastMessageType === "gemini" || session.lastMessageType === "assistant") {
+      return AgentStatus.WAITING;
     }
 
-    /**
-     * Collapse a Gemini message content field into plain text.
-     * Accepts either a pre-joined string (assistant turns) or a Part[]
-     * list (user turns carrying `[{text: "..."}]`). Non-text part
-     * variants (data, file) are dropped since this helper is only used
-     * for summary/conversation rendering.
-     */
-    private resolveContent(content: GeminiMessageContent | undefined): string {
-        if (!content) return '';
-        if (typeof content === 'string') return content;
-        if (!Array.isArray(content)) return '';
-
-        const parts: string[] = [];
-        for (const part of content) {
-            if (part && typeof part.text === 'string' && part.text) {
-                parts.push(part.text);
-            }
-        }
-        return parts.join('');
-    }
+    return AgentStatus.RUNNING;
+  }
 
-    private truncate(value: string, maxLength: number): string {
-        if (value.length <= maxLength) return value;
-        return `${value.slice(0, maxLength - 3)}...`;
+  private extractSummary(messages: GeminiMessageEntry[]): string {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const entry = messages[i];
+      if (entry?.type !== "user") continue;
+      const text = this.messageText(entry).trim();
+      if (text) return this.truncate(text, 120);
     }
 
-    private isGeminiExecutable(command: string): boolean {
-        // Accept any token in the command line whose basename matches a
-        // known gemini entrypoint. This is intentionally broader than the
-        // other adapters' argv[0]-only check because the Node-script
-        // distribution puts the real gemini path in argv[1..], not argv[0].
-        for (const token of command.trim().split(/\s+/)) {
-            const base = executableBasename(token);
-            if (base === 'gemini' || base === 'gemini.exe' || base === 'gemini.js') {
-                return true;
-            }
-        }
-        return false;
+    return "Gemini CLI session active";
+  }
+
+  /**
+   * Normalize an entry's content/displayContent into a plain string.
+   * Prefers displayContent when both are present (matches Gemini CLI's
+   * own rendering priority for the /chat UI).
+   */
+  private messageText(entry: GeminiMessageEntry): string {
+    const displayText = this.resolveContent(entry.displayContent);
+    if (displayText) return displayText;
+    return this.resolveContent(entry.content);
+  }
+
+  /**
+   * Collapse a Gemini message content field into plain text.
+   * Accepts either a pre-joined string (assistant turns) or a Part[]
+   * list (user turns carrying `[{text: "..."}]`). Non-text part
+   * variants (data, file) are dropped since this helper is only used
+   * for summary/conversation rendering.
+   */
+  private resolveContent(content: GeminiMessageContent | undefined): string {
+    if (!content) return "";
+    if (typeof content === "string") return content;
+    if (!Array.isArray(content)) return "";
+
+    const parts: string[] = [];
+    for (const part of content) {
+      if (part && typeof part.text === "string" && part.text) {
+        parts.push(part.text);
+      }
+    }
+    return parts.join("");
+  }
+
+  private truncate(value: string, maxLength: number): string {
+    if (value.length <= maxLength) return value;
+    return `${value.slice(0, maxLength - 3)}...`;
+  }
+
+  private isGeminiExecutable(command: string): boolean {
+    // Accept any token in the command line whose basename matches a
+    // known gemini entrypoint. This is intentionally broader than the
+    // other adapters' argv[0]-only check because the Node-script
+    // distribution puts the real gemini path in argv[1..], not argv[0].
+    for (const token of command.trim().split(/\s+/)) {
+      const base = executableBasename(token);
+      if (base === "gemini" || base === "gemini.exe" || base === "gemini.js") {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Read the full conversation from a Gemini CLI session JSON file.
+   *
+   * Gemini sessions store messages in an array with `type` field — typically
+   * 'user' or 'gemini' for visible turns, with tool and system entries mixed in.
+   */
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    const verbose = options?.verbose ?? false;
+
+    const content = safeReadFile(sessionFilePath);
+    if (content === undefined) return [];
+
+    let parsed: GeminiSessionFile;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return [];
     }
 
-    /**
-     * Read the full conversation from a Gemini CLI session JSON file.
-     *
-     * Gemini sessions store messages in an array with `type` field — typically
-     * 'user' or 'gemini' for visible turns, with tool and system entries mixed in.
-     */
-    getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
-        const verbose = options?.verbose ?? false;
+    const messages: ConversationMessage[] = [];
+    if (!Array.isArray(parsed.messages)) return messages;
+
+    for (const entry of parsed.messages) {
+      const entryType = entry?.type;
+      if (!entryType) continue;
+
+      let role: ConversationMessage["role"];
+      if (entryType === "user") {
+        role = "user";
+      } else if (entryType === "gemini" || entryType === "assistant") {
+        role = "assistant";
+      } else if (verbose) {
+        role = "system";
+      } else {
+        continue;
+      }
+
+      const text = this.messageText(entry).trim();
+      if (!text) continue;
+
+      messages.push({
+        role,
+        content: text,
+        timestamp: entry.timestamp,
+      });
+    }
 
-        const content = safeReadFile(sessionFilePath);
-        if (content === undefined) return [];
+    return messages;
+  }
 
-        let parsed: GeminiSessionFile;
-        try {
-            parsed = JSON.parse(content);
-        } catch {
-            return [];
-        }
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    if (!isDirectory(this.geminiTmpDir)) return [];
 
-        const messages: ConversationMessage[] = [];
-        if (!Array.isArray(parsed.messages)) return messages;
-
-        for (const entry of parsed.messages) {
-            const entryType = entry?.type;
-            if (!entryType) continue;
-
-            let role: ConversationMessage['role'];
-            if (entryType === 'user') {
-                role = 'user';
-            } else if (entryType === 'gemini' || entryType === 'assistant') {
-                role = 'assistant';
-            } else if (verbose) {
-                role = 'system';
-            } else {
-                continue;
-            }
-
-            const text = this.messageText(entry).trim();
-            if (!text) continue;
-
-            messages.push({
-                role,
-                content: text,
-                timestamp: entry.timestamp,
-            });
-        }
+    const summaries: SessionSummary[] = [];
 
-        return messages;
-    }
+    for (const shortId of safeReaddir(this.geminiTmpDir)) {
+      const chatsDir = path.join(this.geminiTmpDir, shortId, GeminiCliAdapter.CHATS_DIR_NAME);
+      if (!isDirectory(chatsDir)) continue;
 
-    async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
-        if (!isDirectory(this.geminiTmpDir)) return [];
-
-        const summaries: SessionSummary[] = [];
-
-        for (const shortId of safeReaddir(this.geminiTmpDir)) {
-            const chatsDir = path.join(
-                this.geminiTmpDir,
-                shortId,
-                GeminiCliAdapter.CHATS_DIR_NAME,
-            );
-            if (!isDirectory(chatsDir)) continue;
-
-            for (const fileName of safeReaddir(chatsDir)) {
-                if (
-                    !fileName.startsWith(GeminiCliAdapter.SESSION_FILE_PREFIX) ||
-                    !fileName.endsWith('.json')
-                ) {
-                    continue;
-                }
-
-                const filePath = path.join(chatsDir, fileName);
-                const summary = this.fileToSessionSummary(filePath);
-                if (!summary) continue;
-                if (opts?.cwd !== undefined && summary.cwd !== opts.cwd) continue;
-                summaries.push(summary);
-            }
+      for (const fileName of safeReaddir(chatsDir)) {
+        if (
+          !fileName.startsWith(GeminiCliAdapter.SESSION_FILE_PREFIX) ||
+          !fileName.endsWith(".json")
+        ) {
+          continue;
         }
 
-        return summaries;
+        const filePath = path.join(chatsDir, fileName);
+        const summary = this.fileToSessionSummary(filePath);
+        if (!summary) continue;
+        if (opts?.cwd !== undefined && summary.cwd !== opts.cwd) continue;
+        summaries.push(summary);
+      }
     }
 
-    /**
-     * Read a Gemini session JSON file and produce a {@link SessionSummary}.
-     * Returns null when the file is unreadable, the JSON doesn't parse,
-     * or the body lacks a sessionId.
-     */
-    private fileToSessionSummary(filePath: string): SessionSummary | null {
-        const content = safeReadFile(filePath);
-        if (content === undefined) return null;
-
-        let parsed: GeminiSessionFile;
-        try {
-            parsed = JSON.parse(content);
-        } catch {
-            return null;
-        }
-
-        if (!parsed.sessionId) return null;
-
-        const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
-        const firstUserMessage = this.extractFirstUserMessage(messages);
-
-        const cwd =
-            Array.isArray(parsed.directories) && parsed.directories.length > 0
-                ? parsed.directories[0]
-                : '';
-
-        const stat = safeStat(filePath);
-
-        const lastEntryTimestamp = this.parseTimestamp(
-            messages.length > 0 ? messages[messages.length - 1]?.timestamp : undefined,
-        );
-        const lastActive =
-            this.parseTimestamp(parsed.lastUpdated) ||
-            lastEntryTimestamp ||
-            stat?.mtime ||
-            new Date();
-        const startedAt =
-            this.parseTimestamp(parsed.startTime) || stat?.birthtime || stat?.mtime || lastActive;
-
-        return {
-            type: 'gemini_cli',
-            sessionId: parsed.sessionId,
-            cwd,
-            firstUserMessage,
-            lastActive,
-            startedAt,
-            sessionFilePath: filePath,
-        };
+    return summaries;
+  }
+
+  /**
+   * Read a Gemini session JSON file and produce a {@link SessionSummary}.
+   * Returns null when the file is unreadable, the JSON doesn't parse,
+   * or the body lacks a sessionId.
+   */
+  private fileToSessionSummary(filePath: string): SessionSummary | null {
+    const content = safeReadFile(filePath);
+    if (content === undefined) return null;
+
+    let parsed: GeminiSessionFile;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return null;
     }
 
-    private extractFirstUserMessage(messages: GeminiMessageEntry[]): string {
-        for (const entry of messages) {
-            if (entry?.type !== 'user') continue;
-            const text = this.messageText(entry).trim();
-            if (text) return text;
-        }
-        return '';
+    if (!parsed.sessionId) return null;
+
+    const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+    const firstUserMessage = this.extractFirstUserMessage(messages);
+
+    const cwd =
+      Array.isArray(parsed.directories) && parsed.directories.length > 0
+        ? parsed.directories[0]
+        : "";
+
+    const stat = safeStat(filePath);
+
+    const lastEntryTimestamp = this.parseTimestamp(
+      messages.length > 0 ? messages[messages.length - 1]?.timestamp : undefined,
+    );
+    const lastActive =
+      this.parseTimestamp(parsed.lastUpdated) || lastEntryTimestamp || stat?.mtime || new Date();
+    const startedAt =
+      this.parseTimestamp(parsed.startTime) || stat?.birthtime || stat?.mtime || lastActive;
+
+    return {
+      type: "gemini_cli",
+      sessionId: parsed.sessionId,
+      cwd,
+      firstUserMessage,
+      lastActive,
+      startedAt,
+      sessionFilePath: filePath,
+    };
+  }
+
+  private extractFirstUserMessage(messages: GeminiMessageEntry[]): string {
+    for (const entry of messages) {
+      if (entry?.type !== "user") continue;
+      const text = this.messageText(entry).trim();
+      if (text) return text;
     }
+    return "";
+  }
 }