@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/harnesses/antigravity/AntigravityCliAdapter.ts

@@ -0,0 +1,126 @@
+import type {
+  AgentAdapter,
+  AgentDetectionContext,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  ConversationOptions,
+  SessionSummary,
+  ListSessionsOptions,
+} from "../../adapters/AgentAdapter.js";
+import { findHarnessProcesses, matchesExecutable } from "../shared.js";
+import { AntigravityAgentMapper } from "./AntigravityAgentMapper.js";
+import { AntigravitySessionLocator } from "./AntigravitySessionLocator.js";
+import { AntigravitySessionParser, type AntigravitySession } from "./AntigravitySessionParser.js";
+
+/**
+ * Antigravity CLI Adapter
+ *
+ * Detects running Antigravity CLI agents (Google's `agy` native binary) by:
+ * 1. Filtering `agy` processes from the shared process snapshot.
+ * 2. Resolving each process to its conversation via
+ *    ~/.gemini/antigravity-cli/cache/last_conversations.json, a
+ *    `{ <cwd>: <conversationId> }` map keyed by the process cwd.
+ * 3. Reading brain/<conversationId>/.system_generated/logs/transcript.jsonl;
+ *    the last user request is the summary.
+ *
+ * This is the runtime side of Antigravity, independent of the `antigravity`
+ * environment that configures the Antigravity IDE.
+ */
+export class AntigravityCliAdapter implements AgentAdapter {
+  readonly type = "antigravity_cli" as const;
+  readonly processNames = ["agy"] as const;
+
+  private parser: AntigravitySessionParser;
+  private mapper: AntigravityAgentMapper;
+  private locator: AntigravitySessionLocator;
+
+  constructor() {
+    this.parser = new AntigravitySessionParser();
+    this.mapper = new AntigravityAgentMapper(this.parser);
+    this.locator = new AntigravitySessionLocator();
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return matchesExecutable(processInfo.command, "agy");
+  }
+
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    try {
+      return await this.detectRunningAgents(context);
+    } finally {
+      // Drop cached summaries for sessions that were not part of this refresh
+      this.parser.pruneSessionCache();
+    }
+  }
+
+  private async detectRunningAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    const { processes } = await findHarnessProcesses(this, context);
+    if (processes.length === 0) {
+      return [];
+    }
+
+    const agents: AgentInfo[] = [];
+    for (const { process: proc, cwd, conversation } of this.locator.matchRunningProcesses(
+      processes,
+    )) {
+      const session = conversation
+        ? this.parser.readSessionIncremental(
+            conversation.conversationId,
+            conversation.transcriptPath,
+            cwd,
+          )
+        : null;
+      if (session) {
+        agents.push(this.mapper.mapSessionToAgent({ session, processInfo: proc }));
+      } else {
+        agents.push(this.mapper.mapProcessOnlyAgent(proc, cwd));
+      }
+    }
+    return agents;
+  }
+
+  getConversation(sessionFilePath: string, options?: ConversationOptions): ConversationMessage[] {
+    return this.parser.getConversation(sessionFilePath, options);
+  }
+
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    const filterCwd = opts?.cwd;
+    const summaries: SessionSummary[] = [];
+
+    for (const { cwd, conversationId, transcriptPath } of this.locator.listConversations()) {
+      if (filterCwd !== undefined && cwd !== filterCwd) continue;
+
+      const session = this.parser.readSession(conversationId, transcriptPath, cwd);
+      if (!session) continue;
+
+      summaries.push(this.toSessionSummary(session));
+    }
+
+    return summaries;
+  }
+
+  /** Only registered conversations are listed, so look the id up in the registry. */
+  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {
+    const summaries: SessionSummary[] = [];
+    for (const { cwd, conversationId, transcriptPath } of this.locator.listConversations()) {
+      if (conversationId !== sessionId) continue;
+
+      const session = this.parser.readSession(conversationId, transcriptPath, cwd);
+      if (session) summaries.push(this.toSessionSummary(session));
+    }
+    return summaries;
+  }
+
+  private toSessionSummary(session: AntigravitySession): SessionSummary {
+    return {
+      type: this.type,
+      sessionId: session.sessionId,
+      cwd: session.projectPath,
+      firstUserMessage: session.firstUserMessage || "",
+      lastActive: session.lastActive,
+      startedAt: session.sessionStart,
+      sessionFilePath: session.sessionFilePath,
+    };
+  }
+}

package/src/harnesses/antigravity/AntigravitySessionLocator.ts

@@ -0,0 +1,75 @@
+import * as path from "path";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { safeReadFile } from "../../utils/session.js";
+import { homeDir } from "../shared.js";
+
+const REGISTRY_FILE = path.join("cache", "last_conversations.json");
+const BRAIN_DIR = "brain";
+const TRANSCRIPT_REL = path.join(".system_generated", "logs", "transcript.jsonl");
+
+/** A workspace cwd and the conversation the CLI last used there. */
+export interface AntigravityConversationRef {
+  cwd: string;
+  conversationId: string;
+  transcriptPath: string;
+}
+
+/** A live `agy` process paired with its cwd and (if registered) conversation. */
+export interface AntigravityProcessMatch {
+  process: ProcessInfo;
+  cwd: string;
+  conversation: AntigravityConversationRef | null;
+}
+
+export interface AntigravitySessionLocatorOptions {
+  /** Overrides the base dir (defaults to ANTIGRAVITY_CLI_HOME or ~/.gemini/antigravity-cli). */
+  baseDir?: string;
+}
+
+export class AntigravitySessionLocator {
+  private readonly baseDir: string;
+
+  constructor(options: AntigravitySessionLocatorOptions = {}) {
+    this.baseDir =
+      options.baseDir ??
+      (process.env.ANTIGRAVITY_CLI_HOME || path.join(homeDir(), ".gemini", "antigravity-cli"));
+  }
+
+  /** Pair live processes with their conversation, joined on the process cwd. */
+  matchRunningProcesses(processes: ProcessInfo[]): AntigravityProcessMatch[] {
+    const byCwd = new Map(this.listConversations().map((ref) => [ref.cwd, ref]));
+    return processes.map((proc) => {
+      const cwd = proc.cwd || "";
+      return { process: proc, cwd, conversation: byCwd.get(cwd) ?? null };
+    });
+  }
+
+  /**
+   * Read cache/last_conversations.json, a `{ <cwd>: <conversationId> }` map the
+   * CLI rewrites as the current conversation per workspace changes.
+   */
+  listConversations(): AntigravityConversationRef[] {
+    const content = safeReadFile(path.join(this.baseDir, REGISTRY_FILE));
+    if (content === undefined) return [];
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return [];
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+
+    const refs: AntigravityConversationRef[] = [];
+    for (const [cwd, conversationId] of Object.entries(parsed as Record<string, unknown>)) {
+      if (cwd && typeof conversationId === "string" && conversationId) {
+        refs.push({ cwd, conversationId, transcriptPath: this.transcriptPath(conversationId) });
+      }
+    }
+    return refs;
+  }
+
+  private transcriptPath(conversationId: string): string {
+    return path.join(this.baseDir, BRAIN_DIR, conversationId, TRANSCRIPT_REL);
+  }
+}

package/src/harnesses/antigravity/AntigravitySessionParser.ts

@@ -0,0 +1,252 @@
+import type { ConversationMessage, ConversationOptions } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import {
+  IncrementalJsonlSummary,
+  reduceJsonlContent,
+  type JsonlSummaryBounds,
+  type JsonlSummaryReducer,
+} from "../../utils/IncrementalJsonlSummary.js";
+import { JsonlTailReader, normalizeTail } from "../../utils/jsonlTail.js";
+import { safeReadFile, safeStat } from "../../utils/session.js";
+import { flattenTextBlocks, isIdle, parseTimestamp } from "../shared.js";
+
+/** One line of transcript.jsonl. */
+interface TranscriptRecord {
+  source?: string;
+  type?: string;
+  created_at?: string;
+  content?: unknown;
+}
+
+/** O(1) running summary folded from transcript records, never the turns themselves. */
+interface AntigravitySummaryState {
+  /** A bounded cold start skipped the middle: later lines are not the session's first. */
+  pastHead?: boolean;
+  firstUserMessage?: string;
+  lastUserMessage?: string;
+  lastRole?: ConversationMessage["role"];
+  /** Latest `created_at` seen, in epoch ms. */
+  lastActiveMs?: number;
+}
+
+/** Parsed state for a single conversation. */
+export interface AntigravitySession {
+  sessionId: string;
+  projectPath: string;
+  sessionFilePath: string;
+  sessionStart: Date;
+  lastActive: Date;
+  firstUserMessage?: string;
+  lastUserMessage?: string;
+  lastRole?: ConversationMessage["role"];
+}
+
+export interface AntigravitySessionParserOptions {
+  /** Cold-start scan bounds for `readSessionIncremental` (see IncrementalJsonlSummary). */
+  summaryBounds?: JsonlSummaryBounds | false;
+}
+
+export class AntigravitySessionParser {
+  /** Incremental reader backing `getConversation({ tail })`. */
+  private readonly tailReader = new JsonlTailReader();
+
+  private readonly sessionCache: IncrementalJsonlSummary<AntigravitySummaryState>;
+
+  constructor(options: AntigravitySessionParserOptions = {}) {
+    this.sessionCache = new IncrementalJsonlSummary(this.summaryReducer, {
+      bounds: options.summaryBounds,
+    });
+  }
+
+  /**
+   * Parse a conversation's transcript.jsonl into an {@link AntigravitySession}.
+   * Returns null when the transcript is missing — there is no real session to
+   * surface.
+   */
+  readSession(
+    conversationId: string,
+    transcriptPath: string,
+    projectPath: string,
+  ): AntigravitySession | null {
+    const stat = safeStat(transcriptPath);
+    if (!stat) return null;
+
+    const content = safeReadFile(transcriptPath);
+    const state = content === undefined ? {} : reduceJsonlContent(this.summaryReducer, content);
+    return this.toSession(conversationId, transcriptPath, projectPath, stat, stat.mtime, state);
+  }
+
+  /**
+   * Same result as `readSession`, but backed by a per-instance incremental
+   * cache so repeated refreshes only parse bytes appended since the last call.
+   * Call `pruneSessionCache()` once per refresh to evict files no longer read.
+   *
+   * The first read of a large transcript is a bounded head + tail scan (see
+   * `summaryReducer.skip`).
+   */
+  readSessionIncremental(
+    conversationId: string,
+    transcriptPath: string,
+    projectPath: string,
+  ): AntigravitySession | null {
+    const stat = safeStat(transcriptPath);
+    if (!stat) return null;
+
+    // Present but unreadable: surface the session without a summary, like readSession.
+    const result = this.sessionCache.read(transcriptPath);
+    return this.toSession(
+      conversationId,
+      transcriptPath,
+      projectPath,
+      stat,
+      result?.mtime ?? stat.mtime,
+      result?.state ?? {},
+    );
+  }
+
+  /** Evict cached summaries for files not read since the previous prune. */
+  pruneSessionCache(): void {
+    this.sessionCache.prune();
+  }
+
+  getConversation(transcriptPath: string, options?: ConversationOptions): ConversationMessage[] {
+    const verbose = options?.verbose ?? false;
+    const tail = normalizeTail(options?.tail);
+    if (tail === undefined) {
+      return this.parseTranscript(transcriptPath, verbose);
+    }
+
+    return this.tailReader.read(
+      transcriptPath,
+      tail,
+      {
+        parseLine: (line) => {
+          const record = this.parseRecord(line);
+          return record ? this.recordToMessage(record, verbose) : null;
+        },
+      },
+      String(verbose),
+    );
+  }
+
+  /**
+   * - past the idle threshold → IDLE
+   * - last turn is an assistant reply → WAITING (awaiting user)
+   * - otherwise (last turn was a user message, or unknown) → RUNNING
+   */
+  determineStatus(session: AntigravitySession): AgentStatus {
+    if (isIdle(session.lastActive)) {
+      return AgentStatus.IDLE;
+    }
+    if (session.lastRole === "assistant") {
+      return AgentStatus.WAITING;
+    }
+    return AgentStatus.RUNNING;
+  }
+
+  /**
+   * Fold one transcript record into the O(1) summary: first/last user request,
+   * the role of the last user/assistant turn, and the latest `created_at`.
+   * Uses the same record rules as `getConversation` (see `recordToMessage`).
+   *
+   * `skip` (bounded cold start) keeps the head's first user request and resets
+   * the latest fields, so those come from the tail only; without a timestamp in
+   * the tail, `lastActive` falls back to the file mtime.
+   */
+  private readonly summaryReducer: JsonlSummaryReducer<AntigravitySummaryState> = {
+    initial: () => ({}),
+    reduce: (state, value) => {
+      if (value === null || value === undefined) return state;
+      const record = value as TranscriptRecord;
+
+      let next = state;
+      const atMs = parseTimestamp(record.created_at)?.getTime();
+      if (atMs !== undefined && (next.lastActiveMs === undefined || atMs > next.lastActiveMs)) {
+        next = { ...next, lastActiveMs: atMs };
+      }
+
+      const message = this.recordToMessage(record, false);
+      if (message?.role === "user") {
+        return {
+          ...next,
+          firstUserMessage: next.firstUserMessage ?? (next.pastHead ? undefined : message.content),
+          lastUserMessage: message.content,
+          lastRole: "user",
+        };
+      }
+      if (message?.role === "assistant") return { ...next, lastRole: "assistant" };
+      return next;
+    },
+    skip: (state) => ({ pastHead: true, firstUserMessage: state.firstUserMessage }),
+  };
+
+  private toSession(
+    conversationId: string,
+    transcriptPath: string,
+    projectPath: string,
+    stat: { birthtime: Date },
+    mtime: Date,
+    state: AntigravitySummaryState,
+  ): AntigravitySession {
+    return {
+      sessionId: conversationId,
+      projectPath,
+      sessionFilePath: transcriptPath,
+      sessionStart: stat.birthtime,
+      lastActive: state.lastActiveMs === undefined ? mtime : new Date(state.lastActiveMs),
+      firstUserMessage: state.firstUserMessage,
+      lastUserMessage: state.lastUserMessage,
+      lastRole: state.lastRole,
+    };
+  }
+
+  /** Full pass over transcript.jsonl building every conversation turn. */
+  private parseTranscript(transcriptPath: string, verbose: boolean): ConversationMessage[] {
+    const content = safeReadFile(transcriptPath);
+    if (content === undefined) return [];
+
+    const messages: ConversationMessage[] = [];
+    for (const line of content.trim().split("\n")) {
+      const record = this.parseRecord(line);
+      const message = record ? this.recordToMessage(record, verbose) : null;
+      if (message) messages.push(message);
+    }
+    return messages;
+  }
+
+  private parseRecord(line: string): TranscriptRecord | null {
+    if (!line.trim()) return null;
+    try {
+      return JSON.parse(line) as TranscriptRecord;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * USER_INPUT records are user turns and PLANNER_RESPONSE records are the
+   * model's reply. Everything else — MODEL tool calls (RUN_COMMAND, ...) and
+   * SYSTEM records (history, checkpoints) — is execution detail, shown as a
+   * system message only in verbose mode.
+   */
+  private recordToMessage(record: TranscriptRecord, verbose: boolean): ConversationMessage | null {
+    const text = flattenTextBlocks(record.content);
+    if (record.type === "USER_INPUT") {
+      const request = this.extractUserRequest(text);
+      return request === null ? null : { role: "user", content: request };
+    }
+    if (!text) return null;
+    if (record.type === "PLANNER_RESPONSE") return { role: "assistant", content: text };
+    return verbose ? { role: "system", content: text } : null;
+  }
+
+  /**
+   * The prompt inside <USER_REQUEST>...</USER_REQUEST>, or the whole trimmed
+   * text when the record has no wrapper. Null for an unwrapped blank record.
+   */
+  private extractUserRequest(text: string): string | null {
+    const match = text.match(/<USER_REQUEST>\s*([\s\S]*?)\s*<\/USER_REQUEST>/);
+    if (match) return match[1].trim();
+    return text.trim() || null;
+  }
+}

package/src/harnesses/claude/ClaudeAgentMapper.ts

@@ -0,0 +1,55 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import type { SessionFile } from "../../utils/session.js";
+import { ClaudeSessionParser, type ClaudeSession } from "./ClaudeSessionParser.js";
+import { processOnlyAgent } from "../shared.js";
+
+export interface ClaudeAgentLiveInfo {
+  pidStatus?: AgentStatus;
+  waitingFor?: string;
+}
+
+export interface ClaudeSessionAgentInput {
+  session: ClaudeSession;
+  processInfo: ProcessInfo;
+  sessionFile: SessionFile;
+  liveInfo?: ClaudeAgentLiveInfo;
+}
+
+export class ClaudeAgentMapper {
+  constructor(private readonly parser: ClaudeSessionParser = new ClaudeSessionParser()) {}
+
+  mapSessionToAgent({
+    session,
+    processInfo,
+    sessionFile,
+    liveInfo,
+  }: ClaudeSessionAgentInput): AgentInfo {
+    // Live PID-file status is authoritative when present — JSONL-derived
+    // status mis-classifies sessions whose latest entry is a UI-state
+    // event like `permission-mode` or `ai-title`.
+    const status = liveInfo?.pidStatus ?? this.parser.determineStatus(session);
+    const baseSummary = session.lastUserMessage || "Session started";
+    const summary =
+      status === AgentStatus.WAITING && liveInfo?.waitingFor
+        ? `${baseSummary} — waiting for ${liveInfo.waitingFor}`
+        : baseSummary;
+
+    return {
+      name: generateAgentName(processInfo.cwd, processInfo.pid),
+      type: "claude",
+      status,
+      summary,
+      pid: processInfo.pid,
+      projectPath: sessionFile.resolvedCwd || processInfo.cwd || "",
+      sessionId: sessionFile.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: sessionFile.filePath,
+    };
+  }
+
+  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
+    return processOnlyAgent("claude", processInfo, { summary: "Claude Code process running" });
+  }
+}

package/src/harnesses/claude/ClaudeCodeAdapter.ts

@@ -0,0 +1,175 @@
+import * as path from "path";
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  ConversationOptions,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import { safeStat } from "../../utils/session.js";
+import { ClaudeSessionParser } from "./ClaudeSessionParser.js";
+import { ClaudeAgentMapper } from "./ClaudeAgentMapper.js";
+import { ClaudeSessionLocator } from "./ClaudeSessionLocator.js";
+import { findHarnessProcesses, homeDir, matchesExecutable } from "../shared.js";
+
+/**
+ * Claude Code Adapter
+ *
+ * Detects Claude Code agents by:
+ * 1. Filtering Claude processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
+ * 3. Attempting authoritative PID-file matching via ~/.claude/sessions/<pid>.json
+ * 4. Falling back to CWD+birthtime heuristic (matchProcessesToSessions) for processes without a PID file
+ * 5. Extracting summary from last user message in session JSONL (incrementally
+ *    cached across refreshes, so unchanged transcripts are not re-read)
+ */
+export class ClaudeCodeAdapter implements AgentAdapter {
+  readonly type = "claude" as const;
+  readonly processNames = ["claude"] as const;
+
+  private parser: ClaudeSessionParser;
+  private mapper: ClaudeAgentMapper;
+  private projectsDir: string;
+  private sessionsDir: string;
+
+  constructor() {
+    this.projectsDir = path.join(homeDir(), ".claude", "projects");
+    this.sessionsDir = path.join(homeDir(), ".claude", "sessions");
+    this.parser = new ClaudeSessionParser();
+    this.mapper = new ClaudeAgentMapper(this.parser);
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return matchesExecutable(processInfo.command, "claude");
+  }
+
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    try {
+      return await this.detectRunningAgents(context);
+    } finally {
+      // Drop cached summaries for sessions that were not part of this refresh
+      this.parser.pruneSessionCache();
+    }
+  }
+
+  private async detectRunningAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    const { processes } = await findHarnessProcesses(this, context);
+    if (processes.length === 0) {
+      return [];
+    }
+
+    const { direct, legacyMatches } = this.createLocator().matchRunningProcesses(processes);
+
+    const matchedPids = new Set([
+      ...direct.map((d) => d.process.pid),
+      ...legacyMatches.map((m) => m.process.pid),
+    ]);
+
+    const agents: AgentInfo[] = [];
+
+    // Build agents from direct (resume + PID-file) matches
+    for (const match of direct) {
+      const { process: proc, sessionFile } = match;
+      const sessionData = this.parser.readSessionIncremental(
+        sessionFile.filePath,
+        sessionFile.resolvedCwd,
+      );
+      if (sessionData) {
+        agents.push(
+          this.mapper.mapSessionToAgent({
+            session: sessionData,
+            processInfo: proc,
+            sessionFile,
+            liveInfo: {
+              pidStatus: match.pidStatus,
+              waitingFor: match.waitingFor,
+            },
+          }),
+        );
+      } else {
+        matchedPids.delete(proc.pid);
+      }
+    }
+
+    // Build agents from legacy matches
+    for (const match of legacyMatches) {
+      const sessionData = this.parser.readSessionIncremental(
+        match.session.filePath,
+        match.session.resolvedCwd,
+      );
+      if (sessionData) {
+        agents.push(
+          this.mapper.mapSessionToAgent({
+            session: sessionData,
+            processInfo: match.process,
+            sessionFile: match.session,
+          }),
+        );
+      } else {
+        matchedPids.delete(match.process.pid);
+      }
+    }
+
+    // Any process with no match (direct or legacy) appears as IDLE
+    for (const proc of processes) {
+      if (!matchedPids.has(proc.pid)) {
+        agents.push(this.mapper.mapProcessOnlyAgent(proc));
+      }
+    }
+
+    return agents;
+  }
+
+  private createLocator(): ClaudeSessionLocator {
+    return new ClaudeSessionLocator({
+      projectsDir: this.projectsDir,
+      sessionsDir: this.sessionsDir,
+    });
+  }
+
+  getConversation(sessionFilePath: string, options?: ConversationOptions): ConversationMessage[] {
+    return this.parser.getConversation(sessionFilePath, options);
+  }
+
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    const filterCwd = opts?.cwd;
+    const candidates = this.createLocator().discoverHistoricalSessionFiles();
+    const summaries: SessionSummary[] = [];
+
+    for (const { filePath, defaultCwd } of candidates) {
+      const summary = this.toSessionSummary(filePath, defaultCwd);
+      if (!summary) continue;
+      if (filterCwd !== undefined && summary.cwd !== filterCwd) continue;
+      summaries.push(summary);
+    }
+
+    return summaries;
+  }
+
+  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {
+    return this.createLocator()
+      .findHistoricalSessionFilesById(sessionId)
+      .map(({ filePath, defaultCwd }) => this.toSessionSummary(filePath, defaultCwd))
+      .filter((summary): summary is SessionSummary => summary?.sessionId === sessionId);
+  }
+
+  private toSessionSummary(filePath: string, defaultCwd: string): SessionSummary | null {
+    const session = this.parser.readSession(filePath, defaultCwd);
+    if (!session?.lastEntryType) return null;
+
+    const recordedCwd = session.lastCwd || defaultCwd;
+    const stat = safeStat(filePath);
+    return {
+      type: "claude",
+      sessionId: session.sessionId,
+      cwd: recordedCwd,
+      firstUserMessage: session.firstUserMessage || "",
+      lastActive: session.lastActive ?? stat?.mtime ?? new Date(),
+      startedAt: session.sessionStart ?? stat?.birthtime ?? stat?.mtime ?? new Date(),
+      sessionFilePath: filePath,
+    };
+  }
+}