@ai-devkit/agent-manager 0.35.0 → 0.37.0

package/dist/{providers → harnesses}/gemini/GeminiAgentMapper.js

@@ -1,6 +1,6 @@
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
 import { generateAgentName } from "../../utils/matching.js";
 import { GeminiSessionParser } from "./GeminiSessionParser.js";
+import { processOnlyAgent } from "../shared.js";
 export class GeminiAgentMapper {
     parser;
     constructor(parser = new GeminiSessionParser()){
@@ -21,16 +21,9 @@ export class GeminiAgentMapper {
         };
     }
     mapProcessOnlyAgent(processInfo) {
-        return {
-            name: generateAgentName(processInfo.cwd || "", processInfo.pid),
-            type: "gemini_cli",
-            status: AgentStatus.RUNNING,
-            summary: "Gemini CLI process running",
-            pid: processInfo.pid,
-            projectPath: processInfo.cwd || "",
-            sessionId: `pid-${processInfo.pid}`,
-            lastActive: new Date()
-        };
+        return processOnlyAgent("gemini_cli", processInfo, {
+            summary: "Gemini CLI process running"
+        });
     }
 }
 

package/dist/harnesses/gemini/GeminiAgentMapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/harnesses/gemini/GeminiAgentMapper.ts"],"sourcesContent":["import type { AgentInfo, ProcessInfo } from \"../../adapters/AgentAdapter.js\";\nimport { generateAgentName } from \"../../utils/matching.js\";\nimport { GeminiSessionParser, type GeminiSession } from \"./GeminiSessionParser.js\";\nimport { processOnlyAgent } from \"../shared.js\";\n\nexport class GeminiAgentMapper {\n  constructor(private readonly parser: GeminiSessionParser = new GeminiSessionParser()) {}\n\n  mapSessionToAgent(session: GeminiSession, processInfo: ProcessInfo, filePath: string): AgentInfo {\n    const projectPath = session.projectPath || processInfo.cwd || \"\";\n    return {\n      name: generateAgentName(projectPath, processInfo.pid),\n      type: \"gemini_cli\",\n      status: this.parser.determineStatus(session),\n      summary: session.summary || \"Gemini CLI session active\",\n      pid: processInfo.pid,\n      projectPath,\n      sessionId: session.sessionId,\n      lastActive: session.lastActive,\n      sessionFilePath: filePath,\n    };\n  }\n\n  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {\n    return processOnlyAgent(\"gemini_cli\", processInfo, { summary: \"Gemini CLI process running\" });\n  }\n}\n"],"names":["generateAgentName","GeminiSessionParser","processOnlyAgent","GeminiAgentMapper","parser","mapSessionToAgent","session","processInfo","filePath","projectPath","cwd","name","pid","type","status","determineStatus","summary","sessionId","lastActive","sessionFilePath","mapProcessOnlyAgent"],"mappings":"AACA,SAASA,iBAAiB,QAAQ,0BAA0B;AAC5D,SAASC,mBAAmB,QAA4B,2BAA2B;AACnF,SAASC,gBAAgB,QAAQ,eAAe;AAEhD,OAAO,MAAMC;;IACX,YAAY,AAAiBC,SAA8B,IAAIH,qBAAqB,CAAE;aAAzDG,SAAAA;IAA0D;IAEvFC,kBAAkBC,OAAsB,EAAEC,WAAwB,EAAEC,QAAgB,EAAa;QAC/F,MAAMC,cAAcH,QAAQG,WAAW,IAAIF,YAAYG,GAAG,IAAI;QAC9D,OAAO;YACLC,MAAMX,kBAAkBS,aAAaF,YAAYK,GAAG;YACpDC,MAAM;YACNC,QAAQ,IAAI,CAACV,MAAM,CAACW,eAAe,CAACT;YACpCU,SAASV,QAAQU,OAAO,IAAI;YAC5BJ,KAAKL,YAAYK,GAAG;YACpBH;YACAQ,WAAWX,QAAQW,SAAS;YAC5BC,YAAYZ,QAAQY,UAAU;YAC9BC,iBAAiBX;QACnB;IACF;IAEAY,oBAAoBb,WAAwB,EAAa;QACvD,OAAOL,iBAAiB,cAAcK,aAAa;YAAES,SAAS;QAA6B;IAC7F;AACF"}

package/dist/{providers → harnesses}/gemini/GeminiCliAdapter.d.ts

@@ -4,12 +4,13 @@
  * Detects running Gemini CLI agents by:
  * 1. Filtering Gemini Node processes from a shared asynchronous process snapshot
  * 2. Using snapshot CWD and start-time enrichment
- * 3. Discovering session files from ~/.gemini/tmp/<shortId>/chats/session-*.json
+ * 3. Discovering session files from ~/.gemini/tmp/<shortId>/chats/session-*.jsonl
+ *    (Gemini CLI 0.46+ append-only logs) or legacy session-*.json documents
  * 4. Matching sessions to processes via shared matchProcessesToSessions()
  *    using sha256(cwd) === session.projectHash as the resolvedCwd source
  * 5. Extracting summary from the most recent user message in the session JSON
  */
-import type { AgentAdapter, AgentInfo, ProcessInfo, ConversationMessage, SessionSummary, ListSessionsOptions, AgentDetectionContext } from "../../adapters/AgentAdapter.js";
+import type { AgentAdapter, AgentInfo, ProcessInfo, ConversationMessage, ConversationOptions, SessionSummary, ListSessionsOptions, AgentDetectionContext } from "../../adapters/AgentAdapter.js";
 import { AgentRegistry } from "../../utils/AgentRegistry.js";
 export interface GeminiCliAdapterOptions {
     geminiTmpDir?: string;
@@ -36,9 +37,7 @@ export declare class GeminiCliAdapter implements AgentAdapter {
      * executable or script via isGeminiExecutable().
      */
     detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]>;
-    getConversation(sessionFilePath: string, options?: {
-        verbose?: boolean;
-    }): ConversationMessage[];
+    getConversation(sessionFilePath: string, options?: ConversationOptions): ConversationMessage[];
     listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]>;
     findSessionsById(sessionId: string): Promise<SessionSummary[]>;
     private getGeminiProcesses;

package/dist/harnesses/gemini/GeminiCliAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeminiCliAdapter.d.ts","sourceRoot":"","sources":["../../../src/harnesses/gemini/GeminiCliAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EACT,WAAW,EACX,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,gCAAgC,CAAC;AAOxC,OAAO,EAAE,aAAa,EAAsB,MAAM,8BAA8B,CAAC;AAMjF,MAAM,WAAW,uBAAuB;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,gBAAiB,YAAW,YAAY;IACnD,QAAQ,CAAC,IAAI,EAAG,YAAY,CAAU;IACtC,QAAQ,CAAC,YAAY,oBAAqB;IAE1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;gBAG7C,QAAQ,GAAE,aAAuC,EACjD,OAAO,GAAE,uBAA4B;IAQvC,SAAS,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO;IAI5C;;;;;;;;;;;OAWG;IACG,YAAY,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAoBzE,eAAe,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,mBAAmB,EAAE;IAIxF,YAAY,CAAC,IAAI,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAanE,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;YAQtD,kBAAkB;IAIhC,OAAO,CAAC,mBAAmB;IAuC3B,OAAO,CAAC,oBAAoB;IAY5B,OAAO,CAAC,wBAAwB;IAahC,OAAO,CAAC,wBAAwB;IA4BhC,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,gBAAgB;IAmCxB,OAAO,CAAC,kBAAkB;CAa3B"}

package/dist/{providers → harnesses}/gemini/GeminiCliAdapter.js

@@ -4,16 +4,18 @@
  * Detects running Gemini CLI agents by:
  * 1. Filtering Gemini Node processes from a shared asynchronous process snapshot
  * 2. Using snapshot CWD and start-time enrichment
- * 3. Discovering session files from ~/.gemini/tmp/<shortId>/chats/session-*.json
+ * 3. Discovering session files from ~/.gemini/tmp/<shortId>/chats/session-*.jsonl
+ *    (Gemini CLI 0.46+ append-only logs) or legacy session-*.json documents
  * 4. Matching sessions to processes via shared matchProcessesToSessions()
  *    using sha256(cwd) === session.projectHash as the resolvedCwd source
  * 5. Extracting summary from the most recent user message in the session JSON
- */ import { captureProcessSnapshot, executableBasename, filterByProcessNames, findWrapperProcess, findWrapperProcessPids } from "../../utils/process.js";
+ */ import { executableBasename, findWrapperProcess, findWrapperProcessPids } from "../../utils/process.js";
 import { matchProcessesToSessions } from "../../utils/matching.js";
 import { AgentRegistry } from "../../utils/AgentRegistry.js";
 import { GeminiAgentMapper } from "./GeminiAgentMapper.js";
 import { GeminiSessionLocator } from "./GeminiSessionLocator.js";
 import { GeminiSessionParser } from "./GeminiSessionParser.js";
+import { findHarnessProcesses } from "../shared.js";
 export class GeminiCliAdapter {
     type = "gemini_cli";
     processNames = [
@@ -84,9 +86,7 @@ export class GeminiCliAdapter {
         return [];
     }
     async getGeminiProcesses(context) {
-        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
-        const relevant = filterByProcessNames(snapshot, this.processNames);
-        return relevant.filter((process)=>this.canHandle(process));
+        return (await findHarnessProcesses(this, context)).processes;
     }
     mapSessionDiscovery(discovery, candidateProcesses, allProcesses, registryEntriesByPid) {
         const matches = matchProcessesToSessions(candidateProcesses, discovery.sessions);
@@ -94,8 +94,7 @@ export class GeminiCliAdapter {
         const matchedProcesses = [];
         const agents = [];
         for (const match of matches){
-            const cachedContent = discovery.contentCache.get(match.session.filePath);
-            const sessionData = this.parser.parseSession(cachedContent, match.session.filePath);
+            const sessionData = this.parser.parseSession(undefined, match.session.filePath);
             if (!sessionData) {
                 matchedPids.delete(match.process.pid);
                 continue;

package/dist/harnesses/gemini/GeminiCliAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/harnesses/gemini/GeminiCliAdapter.ts"],"sourcesContent":["/**\n * Gemini CLI Adapter\n *\n * Detects running Gemini CLI agents by:\n * 1. Filtering Gemini Node processes from a shared asynchronous process snapshot\n * 2. Using snapshot CWD and start-time enrichment\n * 3. Discovering session files from ~/.gemini/tmp/<shortId>/chats/session-*.jsonl\n *    (Gemini CLI 0.46+ append-only logs) or legacy session-*.json documents\n * 4. Matching sessions to processes via shared matchProcessesToSessions()\n *    using sha256(cwd) === session.projectHash as the resolvedCwd source\n * 5. Extracting summary from the most recent user message in the session JSON\n */\n\nimport type {\n  AgentAdapter,\n  AgentInfo,\n  ProcessInfo,\n  ConversationMessage,\n  ConversationOptions,\n  SessionSummary,\n  ListSessionsOptions,\n  AgentDetectionContext,\n} from \"../../adapters/AgentAdapter.js\";\nimport {\n  executableBasename,\n  findWrapperProcess,\n  findWrapperProcessPids,\n} from \"../../utils/process.js\";\nimport { matchProcessesToSessions } from \"../../utils/matching.js\";\nimport { AgentRegistry, type RegistryEntry } from \"../../utils/AgentRegistry.js\";\nimport { GeminiAgentMapper } from \"./GeminiAgentMapper.js\";\nimport { GeminiSessionLocator, type GeminiSessionDiscovery } from \"./GeminiSessionLocator.js\";\nimport { GeminiSessionParser } from \"./GeminiSessionParser.js\";\nimport { findHarnessProcesses } from \"../shared.js\";\n\nexport interface GeminiCliAdapterOptions {\n  geminiTmpDir?: string;\n}\n\nexport class GeminiCliAdapter implements AgentAdapter {\n  readonly type = \"gemini_cli\" as const;\n  readonly processNames = [\"node\"] as const;\n\n  private readonly registry: AgentRegistry;\n  private readonly parser: GeminiSessionParser;\n  private readonly mapper: GeminiAgentMapper;\n  private readonly locator: GeminiSessionLocator;\n\n  constructor(\n    registry: AgentRegistry = AgentRegistry.default(),\n    options: GeminiCliAdapterOptions = {},\n  ) {\n    this.registry = registry;\n    this.parser = new GeminiSessionParser();\n    this.mapper = new GeminiAgentMapper(this.parser);\n    this.locator = new GeminiSessionLocator(options);\n  }\n\n  canHandle(processInfo: ProcessInfo): boolean {\n    return this.isGeminiExecutable(processInfo.command);\n  }\n\n  /**\n   * Detect running Gemini CLI agents.\n   *\n   * Gemini CLI ships as a Node script (`bundle/gemini.js` with shebang\n   * `#!/usr/bin/env node`) — unlike Claude Code (native binary per\n   * platform) or Codex CLI (Node wrapper that execs a native Rust\n   * binary). The primary running process is therefore the Node runtime\n   * itself, and `ps aux` lists it as `node /path/to/gemini ...` with\n   * argv[0] = `node`. We scan the Node process pool via the shared\n   * snapshot and keep only those whose command line references the gemini\n   * executable or script via isGeminiExecutable().\n   */\n  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {\n    const processes = await this.getGeminiProcesses(context);\n    if (processes.length === 0) return [];\n\n    const wrapperPids = findWrapperProcessPids(processes);\n    const { cachedAgents, remaining } = this.tryRegistryCache(processes, wrapperPids);\n    if (remaining.length === 0) return this.deduplicateSessionAgents(cachedAgents);\n\n    const candidateProcesses = remaining.filter((proc) => !wrapperPids.has(proc.pid));\n    const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));\n    const discovery = this.locator.discoverSessions(candidateProcesses);\n\n    const agents =\n      discovery.sessions.length === 0\n        ? this.mapProcessOnlyAgents(candidateProcesses, processes, registryEntriesByPid)\n        : this.mapSessionDiscovery(discovery, candidateProcesses, processes, registryEntriesByPid);\n\n    return this.deduplicateSessionAgents([...cachedAgents, ...agents]);\n  }\n\n  getConversation(sessionFilePath: string, options?: ConversationOptions): ConversationMessage[] {\n    return this.parser.getConversation(sessionFilePath, options);\n  }\n\n  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {\n    const summaries: SessionSummary[] = [];\n\n    for (const filePath of this.locator.discoverHistoricalSessionFiles()) {\n      const summary = this.parser.fileToSessionSummary(filePath);\n      if (!summary) continue;\n      if (opts?.cwd !== undefined && summary.cwd !== opts.cwd) continue;\n      summaries.push(summary);\n    }\n\n    return summaries;\n  }\n\n  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {\n    for (const filePath of this.locator.discoverHistoricalSessionFiles()) {\n      const summary = this.parser.fileToSessionSummary(filePath);\n      if (summary?.sessionId === sessionId) return [summary];\n    }\n    return [];\n  }\n\n  private async getGeminiProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {\n    return (await findHarnessProcesses(this, context)).processes;\n  }\n\n  private mapSessionDiscovery(\n    discovery: GeminiSessionDiscovery,\n    candidateProcesses: ProcessInfo[],\n    allProcesses: ProcessInfo[],\n    registryEntriesByPid: Map<number, RegistryEntry>,\n  ): AgentInfo[] {\n    const matches = matchProcessesToSessions(candidateProcesses, discovery.sessions);\n    const matchedPids = new Set(matches.map((m) => m.process.pid));\n    const matchedProcesses: ProcessInfo[] = [];\n    const agents: AgentInfo[] = [];\n\n    for (const match of matches) {\n      const sessionData = this.parser.parseSession(undefined, match.session.filePath);\n      if (!sessionData) {\n        matchedPids.delete(match.process.pid);\n        continue;\n      }\n\n      const agent = this.mapper.mapSessionToAgent(\n        sessionData,\n        match.process,\n        match.session.filePath,\n      );\n      this.applyWrapperRegistryName(agent, match.process, allProcesses, registryEntriesByPid);\n      agents.push(agent);\n      matchedProcesses.push(match.process);\n    }\n\n    const matchedWrapperPids = findWrapperProcessPids(candidateProcesses, matchedProcesses);\n    const unmatchedProcesses = candidateProcesses.filter(\n      (process) => !matchedPids.has(process.pid) && !matchedWrapperPids.has(process.pid),\n    );\n\n    agents.push(\n      ...this.mapProcessOnlyAgents(unmatchedProcesses, allProcesses, registryEntriesByPid),\n    );\n    return agents;\n  }\n\n  private mapProcessOnlyAgents(\n    processes: ProcessInfo[],\n    allProcesses: ProcessInfo[],\n    registryEntriesByPid: Map<number, RegistryEntry>,\n  ): AgentInfo[] {\n    return processes.map((processInfo) => {\n      const agent = this.mapper.mapProcessOnlyAgent(processInfo);\n      this.applyWrapperRegistryName(agent, processInfo, allProcesses, registryEntriesByPid);\n      return agent;\n    });\n  }\n\n  private applyWrapperRegistryName(\n    agent: AgentInfo,\n    processInfo: ProcessInfo,\n    processes: ProcessInfo[],\n    registryEntriesByPid: Map<number, RegistryEntry>,\n  ): void {\n    const wrapper = findWrapperProcess(processes, processInfo);\n    const wrapperEntry = wrapper ? registryEntriesByPid.get(wrapper.pid) : undefined;\n    if (wrapperEntry?.type === this.type) {\n      agent.name = wrapperEntry.name;\n    }\n  }\n\n  private deduplicateSessionAgents(agents: AgentInfo[]): AgentInfo[] {\n    const bySession = new Map<string, AgentInfo>();\n    const result: AgentInfo[] = [];\n\n    for (const agent of agents) {\n      const sessionKey = this.sessionDeduplicationKey(agent);\n      if (!sessionKey) {\n        result.push(agent);\n        continue;\n      }\n\n      const existing = bySession.get(sessionKey);\n      if (!existing) {\n        bySession.set(sessionKey, agent);\n        result.push(agent);\n        continue;\n      }\n\n      if (agent.pid > existing.pid) {\n        bySession.set(sessionKey, agent);\n        const index = result.indexOf(existing);\n        if (index >= 0) result[index] = agent;\n      }\n    }\n\n    return result;\n  }\n\n  private sessionDeduplicationKey(agent: AgentInfo): string | null {\n    if (agent.sessionFilePath) return `file:${agent.sessionFilePath}`;\n    if (agent.sessionId && !agent.sessionId.startsWith(\"pid-\")) {\n      return `session:${agent.sessionId}`;\n    }\n    return null;\n  }\n\n  private tryRegistryCache(\n    processes: ProcessInfo[],\n    wrapperPids: Set<number>,\n  ): {\n    cachedAgents: AgentInfo[];\n    remaining: ProcessInfo[];\n  } {\n    const cachedAgents: AgentInfo[] = [];\n    const remaining: ProcessInfo[] = [];\n    const byPid = new Map(this.registry.list().map((e) => [e.pid, e]));\n\n    for (const proc of processes) {\n      const entry = byPid.get(proc.pid);\n      if (\n        wrapperPids.has(proc.pid) ||\n        !entry ||\n        entry.type !== this.type ||\n        !entry.sessionFilePath\n      ) {\n        remaining.push(proc);\n        continue;\n      }\n\n      const sessionData = this.parser.parseSession(undefined, entry.sessionFilePath);\n      if (!sessionData) {\n        remaining.push(proc);\n        continue;\n      }\n\n      cachedAgents.push(this.mapper.mapSessionToAgent(sessionData, proc, entry.sessionFilePath));\n    }\n\n    return { cachedAgents, remaining };\n  }\n\n  private isGeminiExecutable(command: string): boolean {\n    // Accept any token in the command line whose basename matches a\n    // known gemini entrypoint. This is intentionally broader than the\n    // other adapters' argv[0]-only check because the Node-script\n    // distribution puts the real gemini path in argv[1..], not argv[0].\n    for (const token of command.trim().split(/\\s+/)) {\n      const base = executableBasename(token);\n      if (base === \"gemini\" || base === \"gemini.exe\" || base === \"gemini.js\") {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n"],"names":["executableBasename","findWrapperProcess","findWrapperProcessPids","matchProcessesToSessions","AgentRegistry","GeminiAgentMapper","GeminiSessionLocator","GeminiSessionParser","findHarnessProcesses","GeminiCliAdapter","type","processNames","registry","parser","mapper","locator","default","options","canHandle","processInfo","isGeminiExecutable","command","detectAgents","context","processes","getGeminiProcesses","length","wrapperPids","cachedAgents","remaining","tryRegistryCache","deduplicateSessionAgents","candidateProcesses","filter","proc","has","pid","registryEntriesByPid","Map","list","map","entry","discovery","discoverSessions","agents","sessions","mapProcessOnlyAgents","mapSessionDiscovery","getConversation","sessionFilePath","listSessions","opts","summaries","filePath","discoverHistoricalSessionFiles","summary","fileToSessionSummary","cwd","undefined","push","findSessionsById","sessionId","allProcesses","matches","matchedPids","Set","m","process","matchedProcesses","match","sessionData","parseSession","session","delete","agent","mapSessionToAgent","applyWrapperRegistryName","matchedWrapperPids","unmatchedProcesses","mapProcessOnlyAgent","wrapper","wrapperEntry","get","name","bySession","result","sessionKey","sessionDeduplicationKey","existing","set","index","indexOf","startsWith","byPid","e","token","trim","split","base"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAYD,SACEA,kBAAkB,EAClBC,kBAAkB,EAClBC,sBAAsB,QACjB,yBAAyB;AAChC,SAASC,wBAAwB,QAAQ,0BAA0B;AACnE,SAASC,aAAa,QAA4B,+BAA+B;AACjF,SAASC,iBAAiB,QAAQ,yBAAyB;AAC3D,SAASC,oBAAoB,QAAqC,4BAA4B;AAC9F,SAASC,mBAAmB,QAAQ,2BAA2B;AAC/D,SAASC,oBAAoB,QAAQ,eAAe;AAMpD,OAAO,MAAMC;IACFC,OAAO,aAAsB;IAC7BC,eAAe;QAAC;KAAO,CAAU;IAEzBC,SAAwB;IACxBC,OAA4B;IAC5BC,OAA0B;IAC1BC,QAA8B;IAE/C,YACEH,WAA0BR,cAAcY,OAAO,EAAE,EACjDC,UAAmC,CAAC,CAAC,CACrC;QACA,IAAI,CAACL,QAAQ,GAAGA;QAChB,IAAI,CAACC,MAAM,GAAG,IAAIN;QAClB,IAAI,CAACO,MAAM,GAAG,IAAIT,kBAAkB,IAAI,CAACQ,MAAM;QAC/C,IAAI,CAACE,OAAO,GAAG,IAAIT,qBAAqBW;IAC1C;IAEAC,UAAUC,WAAwB,EAAW;QAC3C,OAAO,IAAI,CAACC,kBAAkB,CAACD,YAAYE,OAAO;IACpD;IAEA;;;;;;;;;;;GAWC,GACD,MAAMC,aAAaC,OAA+B,EAAwB;QACxE,MAAMC,YAAY,MAAM,IAAI,CAACC,kBAAkB,CAACF;QAChD,IAAIC,UAAUE,MAAM,KAAK,GAAG,OAAO,EAAE;QAErC,MAAMC,cAAczB,uBAAuBsB;QAC3C,MAAM,EAAEI,YAAY,EAAEC,SAAS,EAAE,GAAG,IAAI,CAACC,gBAAgB,CAACN,WAAWG;QACrE,IAAIE,UAAUH,MAAM,KAAK,GAAG,OAAO,IAAI,CAACK,wBAAwB,CAACH;QAEjE,MAAMI,qBAAqBH,UAAUI,MAAM,CAAC,CAACC,OAAS,CAACP,YAAYQ,GAAG,CAACD,KAAKE,GAAG;QAC/E,MAAMC,uBAAuB,IAAIC,IAAI,IAAI,CAAC1B,QAAQ,CAAC2B,IAAI,GAAGC,GAAG,CAAC,CAACC,QAAU;gBAACA,MAAML,GAAG;gBAAEK;aAAM;QAC3F,MAAMC,YAAY,IAAI,CAAC3B,OAAO,CAAC4B,gBAAgB,CAACX;QAEhD,MAAMY,SACJF,UAAUG,QAAQ,CAACnB,MAAM,KAAK,IAC1B,IAAI,CAACoB,oBAAoB,CAACd,oBAAoBR,WAAWa,wBACzD,IAAI,CAACU,mBAAmB,CAACL,WAAWV,oBAAoBR,WAAWa;QAEzE,OAAO,IAAI,CAACN,wBAAwB,CAAC;eAAIH;eAAiBgB;SAAO;IACnE;IAEAI,gBAAgBC,eAAuB,EAAEhC,OAA6B,EAAyB;QAC7F,OAAO,IAAI,CAACJ,MAAM,CAACmC,eAAe,CAACC,iBAAiBhC;IACtD;IAEA,MAAMiC,aAAaC,IAA0B,EAA6B;QACxE,MAAMC,YAA8B,EAAE;QAEtC,KAAK,MAAMC,YAAY,IAAI,CAACtC,OAAO,CAACuC,8BAA8B,GAAI;YACpE,MAAMC,UAAU,IAAI,CAAC1C,MAAM,CAAC2C,oBAAoB,CAACH;YACjD,IAAI,CAACE,SAAS;YACd,IAAIJ,MAAMM,QAAQC,aAAaH,QAAQE,GAAG,KAAKN,KAAKM,GAAG,EAAE;YACzDL,UAAUO,IAAI,CAACJ;QACjB;QAEA,OAAOH;IACT;IAEA,MAAMQ,iBAAiBC,SAAiB,EAA6B;QACnE,KAAK,MAAMR,YAAY,IAAI,CAACtC,OAAO,CAACuC,8BAA8B,GAAI;YACpE,MAAMC,UAAU,IAAI,CAAC1C,MAAM,CAAC2C,oBAAoB,CAACH;YACjD,IAAIE,SAASM,cAAcA,WAAW,OAAO;gBAACN;aAAQ;QACxD;QACA,OAAO,EAAE;IACX;IAEA,MAAc9B,mBAAmBF,OAA+B,EAA0B;QACxF,OAAO,AAAC,CAAA,MAAMf,qBAAqB,IAAI,EAAEe,QAAO,EAAGC,SAAS;IAC9D;IAEQuB,oBACNL,SAAiC,EACjCV,kBAAiC,EACjC8B,YAA2B,EAC3BzB,oBAAgD,EACnC;QACb,MAAM0B,UAAU5D,yBAAyB6B,oBAAoBU,UAAUG,QAAQ;QAC/E,MAAMmB,cAAc,IAAIC,IAAIF,QAAQvB,GAAG,CAAC,CAAC0B,IAAMA,EAAEC,OAAO,CAAC/B,GAAG;QAC5D,MAAMgC,mBAAkC,EAAE;QAC1C,MAAMxB,SAAsB,EAAE;QAE9B,KAAK,MAAMyB,SAASN,QAAS;YAC3B,MAAMO,cAAc,IAAI,CAACzD,MAAM,CAAC0D,YAAY,CAACb,WAAWW,MAAMG,OAAO,CAACnB,QAAQ;YAC9E,IAAI,CAACiB,aAAa;gBAChBN,YAAYS,MAAM,CAACJ,MAAMF,OAAO,CAAC/B,GAAG;gBACpC;YACF;YAEA,MAAMsC,QAAQ,IAAI,CAAC5D,MAAM,CAAC6D,iBAAiB,CACzCL,aACAD,MAAMF,OAAO,EACbE,MAAMG,OAAO,CAACnB,QAAQ;YAExB,IAAI,CAACuB,wBAAwB,CAACF,OAAOL,MAAMF,OAAO,EAAEL,cAAczB;YAClEO,OAAOe,IAAI,CAACe;YACZN,iBAAiBT,IAAI,CAACU,MAAMF,OAAO;QACrC;QAEA,MAAMU,qBAAqB3E,uBAAuB8B,oBAAoBoC;QACtE,MAAMU,qBAAqB9C,mBAAmBC,MAAM,CAClD,CAACkC,UAAY,CAACH,YAAY7B,GAAG,CAACgC,QAAQ/B,GAAG,KAAK,CAACyC,mBAAmB1C,GAAG,CAACgC,QAAQ/B,GAAG;QAGnFQ,OAAOe,IAAI,IACN,IAAI,CAACb,oBAAoB,CAACgC,oBAAoBhB,cAAczB;QAEjE,OAAOO;IACT;IAEQE,qBACNtB,SAAwB,EACxBsC,YAA2B,EAC3BzB,oBAAgD,EACnC;QACb,OAAOb,UAAUgB,GAAG,CAAC,CAACrB;YACpB,MAAMuD,QAAQ,IAAI,CAAC5D,MAAM,CAACiE,mBAAmB,CAAC5D;YAC9C,IAAI,CAACyD,wBAAwB,CAACF,OAAOvD,aAAa2C,cAAczB;YAChE,OAAOqC;QACT;IACF;IAEQE,yBACNF,KAAgB,EAChBvD,WAAwB,EACxBK,SAAwB,EACxBa,oBAAgD,EAC1C;QACN,MAAM2C,UAAU/E,mBAAmBuB,WAAWL;QAC9C,MAAM8D,eAAeD,UAAU3C,qBAAqB6C,GAAG,CAACF,QAAQ5C,GAAG,IAAIsB;QACvE,IAAIuB,cAAcvE,SAAS,IAAI,CAACA,IAAI,EAAE;YACpCgE,MAAMS,IAAI,GAAGF,aAAaE,IAAI;QAChC;IACF;IAEQpD,yBAAyBa,MAAmB,EAAe;QACjE,MAAMwC,YAAY,IAAI9C;QACtB,MAAM+C,SAAsB,EAAE;QAE9B,KAAK,MAAMX,SAAS9B,OAAQ;YAC1B,MAAM0C,aAAa,IAAI,CAACC,uBAAuB,CAACb;YAChD,IAAI,CAACY,YAAY;gBACfD,OAAO1B,IAAI,CAACe;gBACZ;YACF;YAEA,MAAMc,WAAWJ,UAAUF,GAAG,CAACI;YAC/B,IAAI,CAACE,UAAU;gBACbJ,UAAUK,GAAG,CAACH,YAAYZ;gBAC1BW,OAAO1B,IAAI,CAACe;gBACZ;YACF;YAEA,IAAIA,MAAMtC,GAAG,GAAGoD,SAASpD,GAAG,EAAE;gBAC5BgD,UAAUK,GAAG,CAACH,YAAYZ;gBAC1B,MAAMgB,QAAQL,OAAOM,OAAO,CAACH;gBAC7B,IAAIE,SAAS,GAAGL,MAAM,CAACK,MAAM,GAAGhB;YAClC;QACF;QAEA,OAAOW;IACT;IAEQE,wBAAwBb,KAAgB,EAAiB;QAC/D,IAAIA,MAAMzB,eAAe,EAAE,OAAO,CAAC,KAAK,EAAEyB,MAAMzB,eAAe,EAAE;QACjE,IAAIyB,MAAMb,SAAS,IAAI,CAACa,MAAMb,SAAS,CAAC+B,UAAU,CAAC,SAAS;YAC1D,OAAO,CAAC,QAAQ,EAAElB,MAAMb,SAAS,EAAE;QACrC;QACA,OAAO;IACT;IAEQ/B,iBACNN,SAAwB,EACxBG,WAAwB,EAIxB;QACA,MAAMC,eAA4B,EAAE;QACpC,MAAMC,YAA2B,EAAE;QACnC,MAAMgE,QAAQ,IAAIvD,IAAI,IAAI,CAAC1B,QAAQ,CAAC2B,IAAI,GAAGC,GAAG,CAAC,CAACsD,IAAM;gBAACA,EAAE1D,GAAG;gBAAE0D;aAAE;QAEhE,KAAK,MAAM5D,QAAQV,UAAW;YAC5B,MAAMiB,QAAQoD,MAAMX,GAAG,CAAChD,KAAKE,GAAG;YAChC,IACET,YAAYQ,GAAG,CAACD,KAAKE,GAAG,KACxB,CAACK,SACDA,MAAM/B,IAAI,KAAK,IAAI,CAACA,IAAI,IACxB,CAAC+B,MAAMQ,eAAe,EACtB;gBACApB,UAAU8B,IAAI,CAACzB;gBACf;YACF;YAEA,MAAMoC,cAAc,IAAI,CAACzD,MAAM,CAAC0D,YAAY,CAACb,WAAWjB,MAAMQ,eAAe;YAC7E,IAAI,CAACqB,aAAa;gBAChBzC,UAAU8B,IAAI,CAACzB;gBACf;YACF;YAEAN,aAAa+B,IAAI,CAAC,IAAI,CAAC7C,MAAM,CAAC6D,iBAAiB,CAACL,aAAapC,MAAMO,MAAMQ,eAAe;QAC1F;QAEA,OAAO;YAAErB;YAAcC;QAAU;IACnC;IAEQT,mBAAmBC,OAAe,EAAW;QACnD,gEAAgE;QAChE,kEAAkE;QAClE,6DAA6D;QAC7D,oEAAoE;QACpE,KAAK,MAAM0E,SAAS1E,QAAQ2E,IAAI,GAAGC,KAAK,CAAC,OAAQ;YAC/C,MAAMC,OAAOlG,mBAAmB+F;YAChC,IAAIG,SAAS,YAAYA,SAAS,gBAAgBA,SAAS,aAAa;gBACtE,OAAO;YACT;QACF;QACA,OAAO;IACT;AACF"}

package/dist/harnesses/gemini/GeminiSessionLocator.d.ts

@@ -0,0 +1,72 @@
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import type { SessionFile } from "../../utils/session.js";
+export interface GeminiSessionDiscovery {
+    sessions: SessionFile[];
+}
+export interface GeminiSessionLocatorOptions {
+    geminiTmpDir?: string;
+}
+export declare class GeminiSessionLocator {
+    private readonly geminiTmpDir;
+    private metadataCache;
+    private markerCache;
+    constructor(options?: GeminiSessionLocatorOptions);
+    /**
+     * Discover session files for the given processes.
+     *
+     * Gemini CLI writes sessions to ~/.gemini/tmp/<shortId>/chats/session-*.jsonl
+     * (0.46+; older versions wrote session-*.json) where <shortId> is either sha256(projectRoot) (legacy) or a slug whose
+     * owner is recorded in <shortId>/.project_root. Each session's projectHash
+     * is matched against sha256 of every candidate project root of a process.
+     *
+     * To keep each refresh cheap:
+     * - project dirs whose name or marker can't belong to a candidate root are
+     *   skipped without listing or opening their chats;
+     * - chat files last modified before the earliest candidate process start
+     *   (minus the matching tolerance) are skipped after a stat;
+     * - sessionId/projectHash come from a bounded head read, cached by
+     *   inode+size+mtime, so unchanged files are never re-read.
+     */
+    discoverSessions(processes: ProcessInfo[]): GeminiSessionDiscovery;
+    discoverHistoricalSessionFiles(): string[];
+    private readCandidateSession;
+    private readSessionMetadata;
+    /**
+     * Read sessionId/projectHash from the first METADATA_HEAD_BYTES. Files that
+     * fit in the head are parsed as JSON exactly; larger files are scanned for
+     * the leading keys and only fully parsed when the head lacks them.
+     */
+    private extractSessionMetadata;
+    /**
+     * A `.jsonl` log's metadata is its first line. Never fall back to reading
+     * the whole log: it only grows, and a log whose first record is not
+     * metadata cannot be attributed from its head anyway.
+     */
+    private extractLogMetadata;
+    private readHead;
+    private matchStringField;
+    private pickMetadata;
+    /**
+     * Decide from the directory name or its `.project_root` marker whether a
+     * project temp dir can hold sessions for a candidate root. Dirs with no
+     * recognisable ownership are scanned conservatively.
+     */
+    private mayBelongToCandidates;
+    private readProjectMarker;
+    private earliestMatchableMtime;
+    private buildCandidateProjects;
+    /** Match Gemini CLI's project registry normalization (lower-cased on Windows). */
+    private normalizeRoot;
+    private candidateProjectRoots;
+    private hashProjectRoot;
+    /**
+     * Session files in a chats dir, in both formats. Resuming a legacy session
+     * makes Gemini CLI continue it in `<name>.jsonl` next to the stale
+     * `<name>.json`, so a `.json` with a `.jsonl` sibling is skipped.
+     */
+    private listSessionFileNames;
+    private toSessionLogName;
+    private isSessionFile;
+    private parseSessionMetadata;
+}
+//# sourceMappingURL=GeminiSessionLocator.d.ts.map

package/dist/harnesses/gemini/GeminiSessionLocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeminiSessionLocator.d.ts","sourceRoot":"","sources":["../../../src/harnesses/gemini/GeminiSessionLocator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAElE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAM1D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,2BAA2B;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAyCD,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,aAAa,CAA4C;IACjE,OAAO,CAAC,WAAW,CAA0C;gBAEjD,OAAO,GAAE,2BAAgC;IAIrD;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,sBAAsB;IA4ClE,8BAA8B,IAAI,MAAM,EAAE;IAgB1C,OAAO,CAAC,oBAAoB;IA4B5B,OAAO,CAAC,mBAAmB;IAQ3B;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,QAAQ;IA6BhB,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,YAAY;IAKpB;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,sBAAsB;IAc9B,OAAO,CAAC,sBAAsB;IAuB9B,kFAAkF;IAClF,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,eAAe;IAIvB;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,oBAAoB;CAO7B"}

package/dist/harnesses/gemini/GeminiSessionLocator.js

@@ -0,0 +1,300 @@
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import { MATCH_TOLERANCE_MS } from "../../utils/matchingConstants.js";
+import { isDirectory, safeReadFile, safeReaddir, safeStat } from "../../utils/session.js";
+import { fileSignature } from "./fileSignature.js";
+import { isSessionLogPath } from "./GeminiSessionParser.js";
+import { homeDir } from "../shared.js";
+const SESSION_FILE_PREFIX = "session-";
+/** Legacy single-document sessions. */ const SESSION_DOCUMENT_EXTENSION = ".json";
+/** Gemini CLI 0.46+ append-only session logs; line 1 is the metadata record. */ const SESSION_LOG_EXTENSION = ".jsonl";
+const CHATS_DIR_NAME = "chats";
+/** Ownership marker Gemini CLI writes into slug-named project temp dirs. */ const PROJECT_ROOT_MARKER = ".project_root";
+/** Legacy Gemini CLI temp dirs are named sha256(projectRoot). */ const LEGACY_HASH_DIR_PATTERN = /^[0-9a-f]{64}$/;
+/** Slack for coarse filesystem timestamp granularity. */ const MTIME_SLACK_MS = 2 * 1000;
+/**
+ * Both formats start with sessionId/projectHash (a legacy document's leading
+ * keys, a log's line-1 metadata record); a small head is enough.
+ */ const METADATA_HEAD_BYTES = 8 * 1024;
+export class GeminiSessionLocator {
+    geminiTmpDir;
+    metadataCache = new Map();
+    markerCache = new Map();
+    constructor(options = {}){
+        this.geminiTmpDir = options.geminiTmpDir ?? path.join(homeDir(), ".gemini", "tmp");
+    }
+    /**
+   * Discover session files for the given processes.
+   *
+   * Gemini CLI writes sessions to ~/.gemini/tmp/<shortId>/chats/session-*.jsonl
+   * (0.46+; older versions wrote session-*.json) where <shortId> is either sha256(projectRoot) (legacy) or a slug whose
+   * owner is recorded in <shortId>/.project_root. Each session's projectHash
+   * is matched against sha256 of every candidate project root of a process.
+   *
+   * To keep each refresh cheap:
+   * - project dirs whose name or marker can't belong to a candidate root are
+   *   skipped without listing or opening their chats;
+   * - chat files last modified before the earliest candidate process start
+   *   (minus the matching tolerance) are skipped after a stat;
+   * - sessionId/projectHash come from a bounded head read, cached by
+   *   inode+size+mtime, so unchanged files are never re-read.
+   */ discoverSessions(processes) {
+        const empty = {
+            sessions: []
+        };
+        if (!fs.existsSync(this.geminiTmpDir)) return empty;
+        const candidates = this.buildCandidateProjects(processes);
+        if (candidates.cwdByHash.size === 0) return empty;
+        let shortIdEntries;
+        try {
+            shortIdEntries = fs.readdirSync(this.geminiTmpDir);
+        } catch  {
+            return empty;
+        }
+        const minMtimeMs = this.earliestMatchableMtime(processes);
+        const nextMetadataCache = new Map();
+        const nextMarkerCache = new Map();
+        const sessions = [];
+        for (const shortId of shortIdEntries){
+            const projectDir = path.join(this.geminiTmpDir, shortId);
+            if (!this.mayBelongToCandidates(projectDir, shortId, candidates, nextMarkerCache)) continue;
+            const chatsDir = path.join(projectDir, CHATS_DIR_NAME);
+            if (!isDirectory(chatsDir)) continue;
+            for (const fileName of this.listSessionFileNames(chatsDir)){
+                const session = this.readCandidateSession(chatsDir, fileName, candidates.cwdByHash, minMtimeMs, nextMetadataCache);
+                if (session) sessions.push(session);
+            }
+        }
+        // Keep metadata only for files still in scope so the caches stay bounded.
+        this.metadataCache = nextMetadataCache;
+        this.markerCache = nextMarkerCache;
+        return {
+            sessions
+        };
+    }
+    discoverHistoricalSessionFiles() {
+        if (!isDirectory(this.geminiTmpDir)) return [];
+        const files = [];
+        for (const shortId of safeReaddir(this.geminiTmpDir)){
+            const chatsDir = path.join(this.geminiTmpDir, shortId, CHATS_DIR_NAME);
+            if (!isDirectory(chatsDir)) continue;
+            for (const fileName of this.listSessionFileNames(chatsDir)){
+                files.push(path.join(chatsDir, fileName));
+            }
+        }
+        return files;
+    }
+    readCandidateSession(chatsDir, fileName, cwdByHash, minMtimeMs, nextMetadataCache) {
+        const filePath = path.join(chatsDir, fileName);
+        const stat = safeStat(filePath);
+        if (!stat || stat.mtimeMs < minMtimeMs) return null;
+        const metadata = this.readSessionMetadata(filePath, stat);
+        nextMetadataCache.set(filePath, metadata);
+        if (!metadata.projectHash) return null;
+        const resolvedCwd = cwdByHash.get(metadata.projectHash);
+        if (!resolvedCwd) return null;
+        return {
+            sessionId: metadata.sessionId || fileName.replace(/\.jsonl?$/, ""),
+            filePath,
+            projectDir: chatsDir,
+            birthtimeMs: stat.birthtimeMs,
+            resolvedCwd
+        };
+    }
+    readSessionMetadata(filePath, stat) {
+        const signature = fileSignature(stat);
+        const cached = this.metadataCache.get(filePath);
+        if (cached?.signature === signature) return cached;
+        return {
+            signature,
+            ...this.extractSessionMetadata(filePath)
+        };
+    }
+    /**
+   * Read sessionId/projectHash from the first METADATA_HEAD_BYTES. Files that
+   * fit in the head are parsed as JSON exactly; larger files are scanned for
+   * the leading keys and only fully parsed when the head lacks them.
+   */ extractSessionMetadata(filePath) {
+        const head = this.readHead(filePath);
+        if (head === null) return {};
+        if (isSessionLogPath(filePath)) return this.extractLogMetadata(head);
+        if (head.complete) return this.pickMetadata(this.parseSessionMetadata(head.text));
+        const sessionId = this.matchStringField(head.text, "sessionId");
+        const projectHash = this.matchStringField(head.text, "projectHash");
+        if (sessionId !== undefined && projectHash !== undefined) {
+            return {
+                sessionId,
+                projectHash
+            };
+        }
+        const content = safeReadFile(filePath);
+        if (content === undefined) return {};
+        return this.pickMetadata(this.parseSessionMetadata(content));
+    }
+    /**
+   * A `.jsonl` log's metadata is its first line. Never fall back to reading
+   * the whole log: it only grows, and a log whose first record is not
+   * metadata cannot be attributed from its head anyway.
+   */ extractLogMetadata(head) {
+        const newline = head.text.indexOf("\n");
+        if (newline !== -1 || head.complete) {
+            const firstLine = newline === -1 ? head.text : head.text.slice(0, newline);
+            return this.pickMetadata(this.parseSessionMetadata(firstLine));
+        }
+        // First line longer than the head: pick the leading keys from its prefix.
+        return {
+            sessionId: this.matchStringField(head.text, "sessionId"),
+            projectHash: this.matchStringField(head.text, "projectHash")
+        };
+    }
+    readHead(filePath) {
+        let fd;
+        try {
+            fd = fs.openSync(filePath, "r");
+            // One extra byte tells "exactly METADATA_HEAD_BYTES long" from "longer".
+            const buffer = Buffer.alloc(METADATA_HEAD_BYTES + 1);
+            let length = 0;
+            while(length < buffer.length){
+                const bytesRead = fs.readSync(fd, buffer, length, buffer.length - length, length);
+                if (bytesRead === 0) break;
+                length += bytesRead;
+            }
+            return {
+                text: buffer.toString("utf-8", 0, Math.min(length, METADATA_HEAD_BYTES)),
+                complete: length <= METADATA_HEAD_BYTES
+            };
+        } catch  {
+            return null;
+        } finally{
+            if (fd !== undefined) {
+                try {
+                    fs.closeSync(fd);
+                } catch  {
+                // Nothing useful to do if closing a read-only descriptor fails.
+                }
+            }
+        }
+    }
+    matchStringField(text, key) {
+        const match = new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`).exec(text);
+        if (!match) return undefined;
+        try {
+            return JSON.parse(`"${match[1]}"`);
+        } catch  {
+            return undefined;
+        }
+    }
+    pickMetadata(parsed) {
+        if (!parsed || typeof parsed !== "object") return {};
+        return {
+            sessionId: parsed.sessionId,
+            projectHash: parsed.projectHash
+        };
+    }
+    /**
+   * Decide from the directory name or its `.project_root` marker whether a
+   * project temp dir can hold sessions for a candidate root. Dirs with no
+   * recognisable ownership are scanned conservatively.
+   */ mayBelongToCandidates(projectDir, shortId, candidates, nextMarkerCache) {
+        if (LEGACY_HASH_DIR_PATTERN.test(shortId)) return candidates.cwdByHash.has(shortId);
+        const projectRoot = this.readProjectMarker(projectDir, nextMarkerCache);
+        if (projectRoot === undefined) return true;
+        return candidates.roots.has(this.normalizeRoot(projectRoot));
+    }
+    readProjectMarker(projectDir, nextMarkerCache) {
+        const markerPath = path.join(projectDir, PROJECT_ROOT_MARKER);
+        const stat = safeStat(markerPath);
+        if (!stat?.isFile()) return undefined;
+        const signature = fileSignature(stat);
+        const cached = this.markerCache.get(markerPath);
+        const projectRoot = cached?.signature === signature ? cached.projectRoot : safeReadFile(markerPath)?.trim();
+        if (!projectRoot) return undefined;
+        nextMarkerCache.set(markerPath, {
+            signature,
+            projectRoot
+        });
+        return projectRoot;
+    }
+    earliestMatchableMtime(processes) {
+        let earliestStartMs = Number.POSITIVE_INFINITY;
+        for (const proc of processes){
+            if (!proc.cwd || !proc.startTime) continue;
+            const startMs = proc.startTime.getTime();
+            if (Number.isFinite(startMs)) earliestStartMs = Math.min(earliestStartMs, startMs);
+        }
+        // No start times: nothing can be windowed safely, so scan every file.
+        if (!Number.isFinite(earliestStartMs)) return Number.NEGATIVE_INFINITY;
+        // A file last modified before (earliest start - matcher tolerance) was also
+        // born before it, so it can never be matched to any candidate process.
+        return earliestStartMs - MATCH_TOLERANCE_MS - MTIME_SLACK_MS;
+    }
+    buildCandidateProjects(processes) {
+        const cwdByHash = new Map();
+        const roots = new Set();
+        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)){
+                roots.add(this.normalizeRoot(candidate));
+                const hash = this.hashProjectRoot(candidate);
+                if (!cwdByHash.has(hash)) {
+                    cwdByHash.set(hash, proc.cwd);
+                }
+            }
+        }
+        return {
+            cwdByHash,
+            roots
+        };
+    }
+    /** Match Gemini CLI's project registry normalization (lower-cased on Windows). */ normalizeRoot(projectRoot) {
+        const resolved = path.resolve(projectRoot);
+        return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    }
+    candidateProjectRoots(cwd) {
+        const roots = [];
+        let current = path.resolve(cwd);
+        let parent = path.dirname(current);
+        while(parent !== current){
+            roots.push(current);
+            current = parent;
+            parent = path.dirname(current);
+        }
+        roots.push(current);
+        return roots;
+    }
+    hashProjectRoot(projectRoot) {
+        return crypto.createHash("sha256").update(projectRoot).digest("hex");
+    }
+    /**
+   * Session files in a chats dir, in both formats. Resuming a legacy session
+   * makes Gemini CLI continue it in `<name>.jsonl` next to the stale
+   * `<name>.json`, so a `.json` with a `.jsonl` sibling is skipped.
+   */ listSessionFileNames(chatsDir) {
+        const sessionFiles = safeReaddir(chatsDir).filter((fileName)=>this.isSessionFile(fileName));
+        const names = new Set(sessionFiles);
+        return sessionFiles.filter((fileName)=>!fileName.endsWith(SESSION_DOCUMENT_EXTENSION) || !names.has(this.toSessionLogName(fileName)));
+    }
+    toSessionLogName(documentFileName) {
+        const baseName = documentFileName.slice(0, -SESSION_DOCUMENT_EXTENSION.length);
+        return `${baseName}${SESSION_LOG_EXTENSION}`;
+    }
+    isSessionFile(fileName) {
+        return fileName.startsWith(SESSION_FILE_PREFIX) && (fileName.endsWith(SESSION_DOCUMENT_EXTENSION) || fileName.endsWith(SESSION_LOG_EXTENSION));
+    }
+    parseSessionMetadata(content) {
+        try {
+            return JSON.parse(content);
+        } catch  {
+            return null;
+        }
+    }
+}
+
+//# sourceMappingURL=GeminiSessionLocator.js.map

package/dist/harnesses/gemini/GeminiSessionLocator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/harnesses/gemini/GeminiSessionLocator.ts"],"sourcesContent":["import * as crypto from \"crypto\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport type { ProcessInfo } from \"../../adapters/AgentAdapter.js\";\nimport { MATCH_TOLERANCE_MS } from \"../../utils/matchingConstants.js\";\nimport type { SessionFile } from \"../../utils/session.js\";\nimport { isDirectory, safeReadFile, safeReaddir, safeStat } from \"../../utils/session.js\";\nimport { fileSignature } from \"./fileSignature.js\";\nimport { isSessionLogPath } from \"./GeminiSessionParser.js\";\nimport { homeDir } from \"../shared.js\";\n\nexport interface GeminiSessionDiscovery {\n  sessions: SessionFile[];\n}\n\nexport interface GeminiSessionLocatorOptions {\n  geminiTmpDir?: string;\n}\n\ninterface GeminiSessionMetadata {\n  sessionId?: string;\n  projectHash?: string;\n}\n\ninterface CachedSessionMetadata extends GeminiSessionMetadata {\n  signature: string;\n}\n\ninterface CachedProjectMarker {\n  signature: string;\n  projectRoot: string;\n}\n\ninterface CandidateProjects {\n  /** sha256(projectRoot) -> process CWD that may own sessions for that root. */\n  cwdByHash: Map<string, string>;\n  /** Normalized candidate project roots, compared against `.project_root` markers. */\n  roots: Set<string>;\n}\n\nconst SESSION_FILE_PREFIX = \"session-\";\n/** Legacy single-document sessions. */\nconst SESSION_DOCUMENT_EXTENSION = \".json\";\n/** Gemini CLI 0.46+ append-only session logs; line 1 is the metadata record. */\nconst SESSION_LOG_EXTENSION = \".jsonl\";\nconst CHATS_DIR_NAME = \"chats\";\n/** Ownership marker Gemini CLI writes into slug-named project temp dirs. */\nconst PROJECT_ROOT_MARKER = \".project_root\";\n/** Legacy Gemini CLI temp dirs are named sha256(projectRoot). */\nconst LEGACY_HASH_DIR_PATTERN = /^[0-9a-f]{64}$/;\n/** Slack for coarse filesystem timestamp granularity. */\nconst MTIME_SLACK_MS = 2 * 1000;\n/**\n * Both formats start with sessionId/projectHash (a legacy document's leading\n * keys, a log's line-1 metadata record); a small head is enough.\n */\nconst METADATA_HEAD_BYTES = 8 * 1024;\n\nexport class GeminiSessionLocator {\n  private readonly geminiTmpDir: string;\n  private metadataCache = new Map<string, CachedSessionMetadata>();\n  private markerCache = new Map<string, CachedProjectMarker>();\n\n  constructor(options: GeminiSessionLocatorOptions = {}) {\n    this.geminiTmpDir = options.geminiTmpDir ?? path.join(homeDir(), \".gemini\", \"tmp\");\n  }\n\n  /**\n   * Discover session files for the given processes.\n   *\n   * Gemini CLI writes sessions to ~/.gemini/tmp/<shortId>/chats/session-*.jsonl\n   * (0.46+; older versions wrote session-*.json) where <shortId> is either sha256(projectRoot) (legacy) or a slug whose\n   * owner is recorded in <shortId>/.project_root. Each session's projectHash\n   * is matched against sha256 of every candidate project root of a process.\n   *\n   * To keep each refresh cheap:\n   * - project dirs whose name or marker can't belong to a candidate root are\n   *   skipped without listing or opening their chats;\n   * - chat files last modified before the earliest candidate process start\n   *   (minus the matching tolerance) are skipped after a stat;\n   * - sessionId/projectHash come from a bounded head read, cached by\n   *   inode+size+mtime, so unchanged files are never re-read.\n   */\n  discoverSessions(processes: ProcessInfo[]): GeminiSessionDiscovery {\n    const empty: GeminiSessionDiscovery = { sessions: [] };\n    if (!fs.existsSync(this.geminiTmpDir)) return empty;\n\n    const candidates = this.buildCandidateProjects(processes);\n    if (candidates.cwdByHash.size === 0) return empty;\n\n    let shortIdEntries: string[];\n    try {\n      shortIdEntries = fs.readdirSync(this.geminiTmpDir);\n    } catch {\n      return empty;\n    }\n\n    const minMtimeMs = this.earliestMatchableMtime(processes);\n    const nextMetadataCache = new Map<string, CachedSessionMetadata>();\n    const nextMarkerCache = new Map<string, CachedProjectMarker>();\n    const sessions: SessionFile[] = [];\n\n    for (const shortId of shortIdEntries) {\n      const projectDir = path.join(this.geminiTmpDir, shortId);\n      if (!this.mayBelongToCandidates(projectDir, shortId, candidates, nextMarkerCache)) continue;\n\n      const chatsDir = path.join(projectDir, CHATS_DIR_NAME);\n      if (!isDirectory(chatsDir)) continue;\n\n      for (const fileName of this.listSessionFileNames(chatsDir)) {\n        const session = this.readCandidateSession(\n          chatsDir,\n          fileName,\n          candidates.cwdByHash,\n          minMtimeMs,\n          nextMetadataCache,\n        );\n        if (session) sessions.push(session);\n      }\n    }\n\n    // Keep metadata only for files still in scope so the caches stay bounded.\n    this.metadataCache = nextMetadataCache;\n    this.markerCache = nextMarkerCache;\n    return { sessions };\n  }\n\n  discoverHistoricalSessionFiles(): string[] {\n    if (!isDirectory(this.geminiTmpDir)) return [];\n\n    const files: string[] = [];\n    for (const shortId of safeReaddir(this.geminiTmpDir)) {\n      const chatsDir = path.join(this.geminiTmpDir, shortId, CHATS_DIR_NAME);\n      if (!isDirectory(chatsDir)) continue;\n\n      for (const fileName of this.listSessionFileNames(chatsDir)) {\n        files.push(path.join(chatsDir, fileName));\n      }\n    }\n\n    return files;\n  }\n\n  private readCandidateSession(\n    chatsDir: string,\n    fileName: string,\n    cwdByHash: Map<string, string>,\n    minMtimeMs: number,\n    nextMetadataCache: Map<string, CachedSessionMetadata>,\n  ): SessionFile | null {\n    const filePath = path.join(chatsDir, fileName);\n\n    const stat = safeStat(filePath);\n    if (!stat || stat.mtimeMs < minMtimeMs) return null;\n\n    const metadata = this.readSessionMetadata(filePath, stat);\n    nextMetadataCache.set(filePath, metadata);\n    if (!metadata.projectHash) return null;\n\n    const resolvedCwd = cwdByHash.get(metadata.projectHash);\n    if (!resolvedCwd) return null;\n\n    return {\n      sessionId: metadata.sessionId || fileName.replace(/\\.jsonl?$/, \"\"),\n      filePath,\n      projectDir: chatsDir,\n      birthtimeMs: stat.birthtimeMs,\n      resolvedCwd,\n    };\n  }\n\n  private readSessionMetadata(filePath: string, stat: fs.Stats): CachedSessionMetadata {\n    const signature = fileSignature(stat);\n    const cached = this.metadataCache.get(filePath);\n    if (cached?.signature === signature) return cached;\n\n    return { signature, ...this.extractSessionMetadata(filePath) };\n  }\n\n  /**\n   * Read sessionId/projectHash from the first METADATA_HEAD_BYTES. Files that\n   * fit in the head are parsed as JSON exactly; larger files are scanned for\n   * the leading keys and only fully parsed when the head lacks them.\n   */\n  private extractSessionMetadata(filePath: string): GeminiSessionMetadata {\n    const head = this.readHead(filePath);\n    if (head === null) return {};\n    if (isSessionLogPath(filePath)) return this.extractLogMetadata(head);\n    if (head.complete) return this.pickMetadata(this.parseSessionMetadata(head.text));\n\n    const sessionId = this.matchStringField(head.text, \"sessionId\");\n    const projectHash = this.matchStringField(head.text, \"projectHash\");\n    if (sessionId !== undefined && projectHash !== undefined) {\n      return { sessionId, projectHash };\n    }\n\n    const content = safeReadFile(filePath);\n    if (content === undefined) return {};\n    return this.pickMetadata(this.parseSessionMetadata(content));\n  }\n\n  /**\n   * A `.jsonl` log's metadata is its first line. Never fall back to reading\n   * the whole log: it only grows, and a log whose first record is not\n   * metadata cannot be attributed from its head anyway.\n   */\n  private extractLogMetadata(head: { text: string; complete: boolean }): GeminiSessionMetadata {\n    const newline = head.text.indexOf(\"\\n\");\n    if (newline !== -1 || head.complete) {\n      const firstLine = newline === -1 ? head.text : head.text.slice(0, newline);\n      return this.pickMetadata(this.parseSessionMetadata(firstLine));\n    }\n    // First line longer than the head: pick the leading keys from its prefix.\n    return {\n      sessionId: this.matchStringField(head.text, \"sessionId\"),\n      projectHash: this.matchStringField(head.text, \"projectHash\"),\n    };\n  }\n\n  private readHead(filePath: string): { text: string; complete: boolean } | null {\n    let fd: number | undefined;\n    try {\n      fd = fs.openSync(filePath, \"r\");\n      // One extra byte tells \"exactly METADATA_HEAD_BYTES long\" from \"longer\".\n      const buffer = Buffer.alloc(METADATA_HEAD_BYTES + 1);\n      let length = 0;\n      while (length < buffer.length) {\n        const bytesRead = fs.readSync(fd, buffer, length, buffer.length - length, length);\n        if (bytesRead === 0) break;\n        length += bytesRead;\n      }\n      return {\n        text: buffer.toString(\"utf-8\", 0, Math.min(length, METADATA_HEAD_BYTES)),\n        complete: length <= METADATA_HEAD_BYTES,\n      };\n    } catch {\n      return null;\n    } finally {\n      if (fd !== undefined) {\n        try {\n          fs.closeSync(fd);\n        } catch {\n          // Nothing useful to do if closing a read-only descriptor fails.\n        }\n      }\n    }\n  }\n\n  private matchStringField(text: string, key: string): string | undefined {\n    const match = new RegExp(`\"${key}\"\\\\s*:\\\\s*\"((?:[^\"\\\\\\\\]|\\\\\\\\.)*)\"`).exec(text);\n    if (!match) return undefined;\n    try {\n      return JSON.parse(`\"${match[1]}\"`) as string;\n    } catch {\n      return undefined;\n    }\n  }\n\n  private pickMetadata(parsed: GeminiSessionMetadata | null): GeminiSessionMetadata {\n    if (!parsed || typeof parsed !== \"object\") return {};\n    return { sessionId: parsed.sessionId, projectHash: parsed.projectHash };\n  }\n\n  /**\n   * Decide from the directory name or its `.project_root` marker whether a\n   * project temp dir can hold sessions for a candidate root. Dirs with no\n   * recognisable ownership are scanned conservatively.\n   */\n  private mayBelongToCandidates(\n    projectDir: string,\n    shortId: string,\n    candidates: CandidateProjects,\n    nextMarkerCache: Map<string, CachedProjectMarker>,\n  ): boolean {\n    if (LEGACY_HASH_DIR_PATTERN.test(shortId)) return candidates.cwdByHash.has(shortId);\n\n    const projectRoot = this.readProjectMarker(projectDir, nextMarkerCache);\n    if (projectRoot === undefined) return true;\n    return candidates.roots.has(this.normalizeRoot(projectRoot));\n  }\n\n  private readProjectMarker(\n    projectDir: string,\n    nextMarkerCache: Map<string, CachedProjectMarker>,\n  ): string | undefined {\n    const markerPath = path.join(projectDir, PROJECT_ROOT_MARKER);\n    const stat = safeStat(markerPath);\n    if (!stat?.isFile()) return undefined;\n\n    const signature = fileSignature(stat);\n    const cached = this.markerCache.get(markerPath);\n    const projectRoot =\n      cached?.signature === signature ? cached.projectRoot : safeReadFile(markerPath)?.trim();\n    if (!projectRoot) return undefined;\n\n    nextMarkerCache.set(markerPath, { signature, projectRoot });\n    return projectRoot;\n  }\n\n  private earliestMatchableMtime(processes: ProcessInfo[]): number {\n    let earliestStartMs = Number.POSITIVE_INFINITY;\n    for (const proc of processes) {\n      if (!proc.cwd || !proc.startTime) continue;\n      const startMs = proc.startTime.getTime();\n      if (Number.isFinite(startMs)) earliestStartMs = Math.min(earliestStartMs, startMs);\n    }\n    // No start times: nothing can be windowed safely, so scan every file.\n    if (!Number.isFinite(earliestStartMs)) return Number.NEGATIVE_INFINITY;\n    // A file last modified before (earliest start - matcher tolerance) was also\n    // born before it, so it can never be matched to any candidate process.\n    return earliestStartMs - MATCH_TOLERANCE_MS - MTIME_SLACK_MS;\n  }\n\n  private buildCandidateProjects(processes: ProcessInfo[]): CandidateProjects {\n    const cwdByHash = new Map<string, string>();\n    const roots = new Set<string>();\n    for (const proc of processes) {\n      if (!proc.cwd) continue;\n\n      // Gemini CLI resolves its project root by walking up from the\n      // startup directory looking for a `.git` boundary marker. A\n      // session's projectHash therefore tracks that ancestor rather\n      // than the process' actual CWD. Enumerate every ancestor as a\n      // candidate so subdirectory invocations still line up with the\n      // session the Gemini process wrote.\n      for (const candidate of this.candidateProjectRoots(proc.cwd)) {\n        roots.add(this.normalizeRoot(candidate));\n        const hash = this.hashProjectRoot(candidate);\n        if (!cwdByHash.has(hash)) {\n          cwdByHash.set(hash, proc.cwd);\n        }\n      }\n    }\n    return { cwdByHash, roots };\n  }\n\n  /** Match Gemini CLI's project registry normalization (lower-cased on Windows). */\n  private normalizeRoot(projectRoot: string): string {\n    const resolved = path.resolve(projectRoot);\n    return process.platform === \"win32\" ? resolved.toLowerCase() : resolved;\n  }\n\n  private candidateProjectRoots(cwd: string): string[] {\n    const roots: string[] = [];\n    let current = path.resolve(cwd);\n    let parent = path.dirname(current);\n    while (parent !== current) {\n      roots.push(current);\n      current = parent;\n      parent = path.dirname(current);\n    }\n    roots.push(current);\n    return roots;\n  }\n\n  private hashProjectRoot(projectRoot: string): string {\n    return crypto.createHash(\"sha256\").update(projectRoot).digest(\"hex\");\n  }\n\n  /**\n   * Session files in a chats dir, in both formats. Resuming a legacy session\n   * makes Gemini CLI continue it in `<name>.jsonl` next to the stale\n   * `<name>.json`, so a `.json` with a `.jsonl` sibling is skipped.\n   */\n  private listSessionFileNames(chatsDir: string): string[] {\n    const sessionFiles = safeReaddir(chatsDir).filter((fileName) => this.isSessionFile(fileName));\n    const names = new Set(sessionFiles);\n    return sessionFiles.filter(\n      (fileName) =>\n        !fileName.endsWith(SESSION_DOCUMENT_EXTENSION) ||\n        !names.has(this.toSessionLogName(fileName)),\n    );\n  }\n\n  private toSessionLogName(documentFileName: string): string {\n    const baseName = documentFileName.slice(0, -SESSION_DOCUMENT_EXTENSION.length);\n    return `${baseName}${SESSION_LOG_EXTENSION}`;\n  }\n\n  private isSessionFile(fileName: string): boolean {\n    return (\n      fileName.startsWith(SESSION_FILE_PREFIX) &&\n      (fileName.endsWith(SESSION_DOCUMENT_EXTENSION) || fileName.endsWith(SESSION_LOG_EXTENSION))\n    );\n  }\n\n  private parseSessionMetadata(content: string): GeminiSessionMetadata | null {\n    try {\n      return JSON.parse(content) as GeminiSessionMetadata;\n    } catch {\n      return null;\n    }\n  }\n}\n"],"names":["crypto","fs","path","MATCH_TOLERANCE_MS","isDirectory","safeReadFile","safeReaddir","safeStat","fileSignature","isSessionLogPath","homeDir","SESSION_FILE_PREFIX","SESSION_DOCUMENT_EXTENSION","SESSION_LOG_EXTENSION","CHATS_DIR_NAME","PROJECT_ROOT_MARKER","LEGACY_HASH_DIR_PATTERN","MTIME_SLACK_MS","METADATA_HEAD_BYTES","GeminiSessionLocator","geminiTmpDir","metadataCache","Map","markerCache","options","join","discoverSessions","processes","empty","sessions","existsSync","candidates","buildCandidateProjects","cwdByHash","size","shortIdEntries","readdirSync","minMtimeMs","earliestMatchableMtime","nextMetadataCache","nextMarkerCache","shortId","projectDir","mayBelongToCandidates","chatsDir","fileName","listSessionFileNames","session","readCandidateSession","push","discoverHistoricalSessionFiles","files","filePath","stat","mtimeMs","metadata","readSessionMetadata","set","projectHash","resolvedCwd","get","sessionId","replace","birthtimeMs","signature","cached","extractSessionMetadata","head","readHead","extractLogMetadata","complete","pickMetadata","parseSessionMetadata","text","matchStringField","undefined","content","newline","indexOf","firstLine","slice","fd","openSync","buffer","Buffer","alloc","length","bytesRead","readSync","toString","Math","min","closeSync","key","match","RegExp","exec","JSON","parse","parsed","test","has","projectRoot","readProjectMarker","roots","normalizeRoot","markerPath","isFile","trim","earliestStartMs","Number","POSITIVE_INFINITY","proc","cwd","startTime","startMs","getTime","isFinite","NEGATIVE_INFINITY","Set","candidate","candidateProjectRoots","add","hash","hashProjectRoot","resolved","resolve","process","platform","toLowerCase","current","parent","dirname","createHash","update","digest","sessionFiles","filter","isSessionFile","names","endsWith","toSessionLogName","documentFileName","baseName","startsWith"],"mappings":"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"}