@ai-devkit/agent-manager 0.34.0 → 0.36.0

package/src/providers/grok/GrokAgentMapper.ts

@@ -0,0 +1,41 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import { GrokSessionParser, type GrokSession } from "./GrokSessionParser.js";
+
+export interface GrokSessionAgentInput {
+  session: GrokSession;
+  processInfo: ProcessInfo;
+}
+
+export class GrokAgentMapper {
+  constructor(private readonly parser: GrokSessionParser = new GrokSessionParser()) {}
+
+  mapSessionToAgent({ session, processInfo }: GrokSessionAgentInput): AgentInfo {
+    return {
+      name: generateAgentName(session.projectPath, processInfo.pid),
+      type: "grok_cli",
+      status: this.parser.determineStatus(session),
+      summary: session.lastUserMessage || "Grok CLI session active",
+      pid: processInfo.pid,
+      projectPath: session.projectPath,
+      sessionId: session.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: session.sessionFilePath,
+    };
+  }
+
+  /** `cwd` is already resolved by the locator (registry first, then process cwd). */
+  mapProcessOnlyAgent(processInfo: ProcessInfo, cwd: string): AgentInfo {
+    return {
+      name: generateAgentName(cwd, processInfo.pid),
+      type: "grok_cli",
+      status: AgentStatus.RUNNING,
+      summary: "Grok CLI process running",
+      pid: processInfo.pid,
+      projectPath: cwd,
+      sessionId: `pid-${processInfo.pid}`,
+      lastActive: new Date(),
+    };
+  }
+}

package/src/providers/grok/GrokCliAdapter.ts

@@ -0,0 +1,125 @@
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import {
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+} from "../../utils/process.js";
+import { GrokAgentMapper } from "./GrokAgentMapper.js";
+import { GrokSessionLocator } from "./GrokSessionLocator.js";
+import { GrokSessionParser, type GrokSession } from "./GrokSessionParser.js";
+
+/**
+ * Grok Build CLI Adapter
+ *
+ * Detects running Grok Build CLI agents by:
+ * 1. Filtering `grok` processes from a shared asynchronous snapshot — Grok is
+ *    a native binary at ~/.grok/bin/grok, so argv[0] basename is `grok`.
+ * 2. Resolving each live process to its working directory via
+ *    ~/.grok/active_sessions.json, which Grok maintains as a list of
+ *    { pid, cwd, opened_at } for every running session. The cwd is then encoded
+ *    into the session group dir ~/.grok/sessions/<encodeURIComponent(cwd)>/, and
+ *    the most recently active session subdirectory is picked from it. The
+ *    process cwd from lsof is only a fallback when the PID is not registered.
+ * 3. Reading the session transcript from chat_history.jsonl (the authoritative
+ *    record of the conversation). The last user turn (the text inside
+ *    <user_query>...</user_query>) is the summary; the file's mtime is the last
+ *    activity time. summary.json / updates.jsonl are intentionally not used.
+ */
+export class GrokCliAdapter implements AgentAdapter {
+  readonly type = "grok_cli" as const;
+  readonly processNames = ["grok"] as const;
+
+  private parser: GrokSessionParser;
+  private mapper: GrokAgentMapper;
+  private locator: GrokSessionLocator;
+
+  constructor() {
+    this.parser = new GrokSessionParser();
+    this.mapper = new GrokAgentMapper(this.parser);
+    this.locator = new GrokSessionLocator();
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return this.isGrokExecutable(processInfo.command);
+  }
+
+  private isGrokExecutable(command: string): boolean {
+    const base = executableBasename(command);
+    return base === "grok" || base === "grok.exe";
+  }
+
+  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 agents: AgentInfo[] = [];
+    for (const { process: proc, cwd, sessionDir } of this.locator.matchRunningProcesses(
+      processes,
+    )) {
+      const session = sessionDir ? this.parser.readSession(sessionDir, 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?: { verbose?: boolean }): ConversationMessage[] {
+    return this.parser.getConversation(sessionFilePath, options);
+  }
+
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    const filterCwd = opts?.cwd;
+    const summaries: SessionSummary[] = [];
+
+    for (const { sessionDir, defaultCwd } of this.locator.discoverHistoricalSessionDirs()) {
+      const session = this.parser.readSession(sessionDir, defaultCwd);
+      if (!session) continue;
+
+      if (filterCwd !== undefined && session.projectPath !== filterCwd) continue;
+
+      summaries.push(this.toSessionSummary(session));
+    }
+
+    return summaries;
+  }
+
+  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {
+    const summaries: SessionSummary[] = [];
+    for (const { sessionDir, defaultCwd } of this.locator.findHistoricalSessionDirsById(
+      sessionId,
+    )) {
+      const session = this.parser.readSession(sessionDir, defaultCwd);
+      if (!session) continue;
+
+      summaries.push(this.toSessionSummary(session));
+    }
+    return summaries;
+  }
+
+  private toSessionSummary(session: GrokSession): 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/providers/grok/GrokSessionLocator.ts

@@ -0,0 +1,179 @@
+import * as path from "path";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import {
+  isDirectory,
+  isSafePathSegment,
+  safeReadFile,
+  safeReaddir,
+  safeStat,
+} from "../../utils/session.js";
+import { CHAT_HISTORY_FILE } from "./GrokSessionParser.js";
+
+const ACTIVE_SESSIONS_FILE = "active_sessions.json";
+const CWD_FILE = ".cwd";
+
+/** One entry of ~/.grok/active_sessions.json. */
+interface ActiveSessionEntry {
+  pid?: number;
+  cwd?: string;
+  opened_at?: number | string;
+}
+
+/** A live Grok process paired with its resolved cwd and (if any) session dir. */
+export interface GrokProcessMatch {
+  process: ProcessInfo;
+  cwd: string;
+  sessionDir: string | null;
+}
+
+/** A historical session dir plus the cwd decoded from its group dir. */
+export interface GrokSessionDir {
+  sessionDir: string;
+  defaultCwd: string;
+}
+
+export interface GrokSessionLocatorOptions {
+  /** Overrides the ~/.grok base directory (defaults to GROK_HOME or ~/.grok). */
+  baseDir?: string;
+}
+
+export class GrokSessionLocator {
+  private readonly baseDir: string;
+  private readonly sessionsDir: string;
+
+  constructor(options: GrokSessionLocatorOptions = {}) {
+    // GROK_HOME overrides the ~/.grok base directory; sessions live under
+    // <base>/sessions/ and the active-session registry at
+    // <base>/active_sessions.json.
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.baseDir = options.baseDir ?? (process.env.GROK_HOME || path.join(homeDir, ".grok"));
+    this.sessionsDir = path.join(this.baseDir, "sessions");
+  }
+
+  /**
+   * Pair live Grok processes with their session dirs.
+   *
+   * active_sessions.json is the authoritative pid -> cwd map for live
+   * sessions; the lsof-derived process cwd is only a fallback. The most
+   * recently active session under that cwd's group dir is picked.
+   */
+  matchRunningProcesses(processes: ProcessInfo[]): GrokProcessMatch[] {
+    const pidToCwd = this.readActiveSessions();
+    return processes.map((proc) => {
+      const cwd = pidToCwd.get(proc.pid) || proc.cwd || "";
+      return { process: proc, cwd, sessionDir: cwd ? this.latestSessionDir(cwd) : null };
+    });
+  }
+
+  /** Every session dir under ~/.grok/sessions/, across all project groups. */
+  discoverHistoricalSessionDirs(): GrokSessionDir[] {
+    const results: GrokSessionDir[] = [];
+    for (const { groupDir, defaultCwd } of this.listGroups()) {
+      for (const sessionDir of this.listSessionDirs(groupDir)) {
+        results.push({ sessionDir, defaultCwd });
+      }
+    }
+    return results;
+  }
+
+  /** Session dirs named exactly `sessionId`, across all project groups. */
+  findHistoricalSessionDirsById(sessionId: string): GrokSessionDir[] {
+    if (!isSafePathSegment(sessionId)) return [];
+
+    const results: GrokSessionDir[] = [];
+    for (const { groupDir, defaultCwd } of this.listGroups()) {
+      const sessionDir = path.join(groupDir, sessionId);
+      if (isDirectory(sessionDir)) {
+        results.push({ sessionDir, defaultCwd });
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Read ~/.grok/active_sessions.json into a pid -> cwd map. Grok writes one
+   * { pid, cwd, opened_at } entry per running session and removes it on exit,
+   * so this is the reliable way to learn a live process's working directory.
+   */
+  private readActiveSessions(): Map<number, string> {
+    const map = new Map<number, string>();
+    const content = safeReadFile(path.join(this.baseDir, ACTIVE_SESSIONS_FILE));
+    if (content === undefined) return map;
+
+    let entries: unknown;
+    try {
+      entries = JSON.parse(content);
+    } catch {
+      return map;
+    }
+    if (!Array.isArray(entries)) return map;
+
+    for (const entry of entries as ActiveSessionEntry[]) {
+      if (typeof entry?.pid === "number" && typeof entry?.cwd === "string" && entry.cwd) {
+        map.set(entry.pid, entry.cwd);
+      }
+    }
+    return map;
+  }
+
+  /**
+   * Return the most recently active session subdirectory for a cwd, i.e. the
+   * ~/.grok/sessions/<encodeURIComponent(cwd)>/<id>/ whose chat_history.jsonl
+   * was written last. Returns null when the group dir or any transcript is
+   * missing.
+   */
+  private latestSessionDir(cwd: string): string | null {
+    const groupDir = path.join(this.sessionsDir, encodeURIComponent(cwd));
+    if (!isDirectory(groupDir)) return null;
+
+    let best: { dir: string; mtimeMs: number } | null = null;
+    for (const sessionDir of this.listSessionDirs(groupDir)) {
+      const stat = safeStat(path.join(sessionDir, CHAT_HISTORY_FILE));
+      if (!stat) continue;
+      if (!best || stat.mtimeMs > best.mtimeMs) {
+        best = { dir: sessionDir, mtimeMs: stat.mtimeMs };
+      }
+    }
+    return best?.dir ?? null;
+  }
+
+  private listGroups(): Array<{ groupDir: string; defaultCwd: string }> {
+    if (!isDirectory(this.sessionsDir)) return [];
+
+    const groups: Array<{ groupDir: string; defaultCwd: string }> = [];
+    for (const groupName of safeReaddir(this.sessionsDir)) {
+      const groupDir = path.join(this.sessionsDir, groupName);
+      if (!isDirectory(groupDir)) continue;
+      groups.push({ groupDir, defaultCwd: this.decodeGroupCwd(groupName, groupDir) });
+    }
+    return groups;
+  }
+
+  /**
+   * Full paths of the session subdirectories directly under a group dir,
+   * skipping any non-directory entries (e.g. prompt_history.jsonl).
+   */
+  private listSessionDirs(groupDir: string): string[] {
+    return safeReaddir(groupDir)
+      .map((sessionId) => path.join(groupDir, sessionId))
+      .filter((sessionDir) => isDirectory(sessionDir));
+  }
+
+  /**
+   * Resolve the working directory a session group dir was created for.
+   *
+   * The common case is `decodeURIComponent(<group-name>)`. For paths whose
+   * encoded form exceeds the filesystem limit Grok uses a slug+hash and records
+   * the original path in a `.cwd` file inside the group — prefer that when
+   * present.
+   */
+  private decodeGroupCwd(groupName: string, groupDir: string): string {
+    const fromFile = safeReadFile(path.join(groupDir, CWD_FILE));
+    if (fromFile !== undefined && fromFile.trim()) return fromFile.trim();
+    try {
+      return decodeURIComponent(groupName);
+    } catch {
+      return "";
+    }
+  }
+}

package/src/providers/grok/GrokSessionParser.ts

@@ -0,0 +1,166 @@
+import * as path from "path";
+import type { ConversationMessage } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { safeReadFile, safeStat } from "../../utils/session.js";
+
+export const CHAT_HISTORY_FILE = "chat_history.jsonl";
+const IDLE_THRESHOLD_MINUTES = 5;
+
+/** One line of chat_history.jsonl. */
+interface ChatRecord {
+  type?: string;
+  content?: unknown;
+}
+
+interface ChatScan {
+  messages: ConversationMessage[];
+  firstUserMessage?: string;
+  lastUserMessage?: string;
+  lastRole?: ConversationMessage["role"];
+}
+
+/** Parsed state for a single ~/.grok/sessions/<cwd>/<id>/ directory. */
+export interface GrokSession {
+  sessionId: string;
+  projectPath: string;
+  sessionFilePath: string;
+  sessionStart: Date;
+  lastActive: Date;
+  firstUserMessage?: string;
+  lastUserMessage?: string;
+  lastRole?: ConversationMessage["role"];
+}
+
+export class GrokSessionParser {
+  /**
+   * Parse a session directory into a {@link GrokSession} from its
+   * chat_history.jsonl transcript. Returns null when the transcript is
+   * missing — i.e. there is no real session to surface.
+   */
+  readSession(sessionDir: string, defaultCwd: string): GrokSession | null {
+    const chatPath = path.join(sessionDir, CHAT_HISTORY_FILE);
+    const chatStat = safeStat(chatPath);
+    if (!chatStat) return null;
+
+    const scan = this.parseChatHistory(chatPath, false);
+    const dirStat = safeStat(sessionDir);
+    const lastActive = chatStat.mtime;
+
+    return {
+      sessionId: path.basename(sessionDir),
+      projectPath: defaultCwd,
+      sessionFilePath: chatPath,
+      sessionStart: dirStat?.birthtime || lastActive,
+      lastActive,
+      firstUserMessage: scan.firstUserMessage,
+      lastUserMessage: scan.lastUserMessage,
+      lastRole: scan.lastRole,
+    };
+  }
+
+  /** Accepts a session dir or an explicit chat_history.jsonl path. */
+  getConversation(sessionPath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    return this.parseChatHistory(this.resolveChatPath(sessionPath), options?.verbose ?? false)
+      .messages;
+  }
+
+  /**
+   * Determine agent status from parsed session state.
+   *
+   * - past the idle threshold → IDLE
+   * - last transcript turn is an assistant message → WAITING (awaiting user)
+   * - otherwise (last turn was a user message, or unknown) → RUNNING
+   */
+  determineStatus(session: GrokSession): AgentStatus {
+    const diffMinutes = (Date.now() - session.lastActive.getTime()) / 60000;
+    if (diffMinutes > IDLE_THRESHOLD_MINUTES) {
+      return AgentStatus.IDLE;
+    }
+    if (session.lastRole === "assistant") {
+      return AgentStatus.WAITING;
+    }
+    return AgentStatus.RUNNING;
+  }
+
+  /**
+   * Single pass over chat_history.jsonl. Each line is a
+   * { type: 'system' | 'user' | 'assistant', content } record where content is
+   * either a string or an array of { type: 'text', text } blocks.
+   *
+   * Grok wraps the real user prompt in <user_query>...</user_query>; the other
+   * user records are context injections (<user_info>, <system-reminder>, ...)
+   * and are skipped so the summary is the actual prompt, not boilerplate.
+   */
+  private parseChatHistory(chatPath: string, verbose: boolean): ChatScan {
+    const content = safeReadFile(chatPath);
+    if (content === undefined) return { messages: [] };
+
+    const messages: ConversationMessage[] = [];
+    let lastRole: ConversationMessage["role"] | undefined;
+
+    for (const line of content.trim().split("\n")) {
+      if (!line.trim()) continue;
+
+      let record: ChatRecord;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      const text = this.extractText(record.content);
+      if (record.type === "user") {
+        const query = this.extractUserQuery(text);
+        if (query === null) continue; // context injection, not a real prompt
+        messages.push({ role: "user", content: query });
+        lastRole = "user";
+      } else if (record.type === "assistant") {
+        if (!text) continue;
+        messages.push({ role: "assistant", content: text });
+        lastRole = "assistant";
+      } else if (verbose && record.type === "system") {
+        if (!text) continue;
+        messages.push({ role: "system", content: text });
+      }
+    }
+
+    const userTurns = messages.filter((m) => m.role === "user");
+    return {
+      messages,
+      firstUserMessage: userTurns[0]?.content,
+      lastUserMessage: userTurns[userTurns.length - 1]?.content,
+      lastRole,
+    };
+  }
+
+  /** Flatten a chat record's content (string or text-block array) to text. */
+  private extractText(content: unknown): string {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content
+        .map((block) =>
+          block &&
+          typeof block === "object" &&
+          typeof (block as { text?: unknown }).text === "string"
+            ? (block as { text: string }).text
+            : "",
+        )
+        .join("");
+    }
+    return "";
+  }
+
+  /**
+   * Extract the prompt inside <user_query>...</user_query>. Returns null when
+   * the record has no such tag (a context injection rather than a prompt).
+   */
+  private extractUserQuery(text: string): string | null {
+    const match = text.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/);
+    return match ? match[1].trim() : null;
+  }
+
+  /** Resolve a session dir or an explicit chat_history.jsonl path to the file. */
+  private resolveChatPath(sessionPath: string): string {
+    return sessionPath.endsWith(".jsonl") ? sessionPath : path.join(sessionPath, CHAT_HISTORY_FILE);
+  }
+}

package/src/providers/opencode/OpenCodeAdapter.ts

@@ -109,4 +109,8 @@ export class OpenCodeAdapter implements AgentAdapter {
   async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
     return this.locator.listSessions(opts);
   }
+
+  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {
+    return this.locator.findSessionsById(sessionId);
+  }
 }

package/src/providers/opencode/OpenCodeSessionLocator.ts

@@ -16,6 +16,12 @@ export interface OpenCodeSession {
   timeCreated: number;
 }
 
+interface OpenCodeSessionRow {
+  id: string;
+  directory: string;
+  timeCreated: number;
+}
+
 export class OpenCodeSessionLocator {
   private readonly dbPath: string;
   private db: Database.Database | null = null;
@@ -82,7 +88,7 @@ export class OpenCodeSessionLocator {
 
     try {
       const rows = db
-        .prepare<[], { id: string; directory: string; timeCreated: number }>(`
+        .prepare<[], OpenCodeSessionRow>(`
                 SELECT id, directory, time_created AS timeCreated
                 FROM session
                 ORDER BY time_created DESC
@@ -94,20 +100,7 @@ export class OpenCodeSessionLocator {
       for (const row of rows) {
         if (opts?.cwd !== undefined && row.directory !== opts.cwd) continue;
 
-        const stats = this.parser.getSessionStats(db, row.id);
-        const lastActive =
-          stats.lastTimeUpdated > 0 ? new Date(stats.lastTimeUpdated) : new Date(row.timeCreated);
-        const startedAt = new Date(row.timeCreated);
-
-        summaries.push({
-          type: "opencode",
-          sessionId: row.id,
-          cwd: row.directory,
-          firstUserMessage: stats.summary,
-          lastActive,
-          startedAt,
-          sessionFilePath: encodeOpenCodeSessionRef(this.dbPath, row.id),
-        });
+        summaries.push(this.toSessionSummary(db, row));
       }
 
       return summaries;
@@ -117,6 +110,41 @@ export class OpenCodeSessionLocator {
     }
   }
 
+  findSessionsById(sessionId: string): SessionSummary[] {
+    const db = this.openDb();
+    if (!db) return [];
+
+    try {
+      const row = db
+        .prepare<[string], OpenCodeSessionRow>(`
+                SELECT id, directory, time_created AS timeCreated
+                FROM session
+                WHERE id = ?
+            `)
+        .get(sessionId);
+      return row ? [this.toSessionSummary(db, row)] : [];
+    } catch {
+      this.close();
+      return [];
+    }
+  }
+
+  private toSessionSummary(db: Database.Database, row: OpenCodeSessionRow): SessionSummary {
+    const stats = this.parser.getSessionStats(db, row.id);
+    const lastActive =
+      stats.lastTimeUpdated > 0 ? new Date(stats.lastTimeUpdated) : new Date(row.timeCreated);
+
+    return {
+      type: "opencode",
+      sessionId: row.id,
+      cwd: row.directory,
+      firstUserMessage: stats.summary,
+      lastActive,
+      startedAt: new Date(row.timeCreated),
+      sessionFilePath: encodeOpenCodeSessionRef(this.dbPath, row.id),
+    };
+  }
+
   get dbFilePath(): string {
     return this.dbPath;
   }

package/src/providers/pi/PiAdapter.ts

@@ -92,6 +92,18 @@ export class PiAdapter implements AgentAdapter {
     return summaries;
   }
 
+  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {
+    const summaries: SessionSummary[] = [];
+    const filePaths = this.createLocator().findHistoricalSessionFilesById(sessionId);
+    for (const filePath of filePaths) {
+      const summary = this.parser.fileToSessionSummary(filePath);
+      if (summary?.sessionId === sessionId) summaries.push(summary);
+    }
+
+    if (summaries.length > 0) return summaries;
+    return (await this.listSessions()).filter((summary) => summary.sessionId === sessionId);
+  }
+
   private async getPiProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {
     const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
     const relevant = filterByProcessNames(snapshot, this.processNames);

package/src/providers/pi/PiSessionLocator.ts

@@ -1,7 +1,13 @@
 import * as path from "path";
 import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
 import { matchProcessesToSessions, type MatchResult } from "../../utils/matching.js";
-import { isDirectory, safeReaddir, safeStat, type SessionFile } from "../../utils/session.js";
+import {
+  isDirectory,
+  isSafePathSegment,
+  safeReaddir,
+  safeStat,
+  type SessionFile,
+} from "../../utils/session.js";
 import { PiSessionParser } from "./PiSessionParser.js";
 
 export interface PiSessionLocatorOptions {
@@ -64,6 +70,15 @@ export class PiSessionLocator {
     return this.collectJsonlFiles(this.sessionsDir);
   }
 
+  findHistoricalSessionFilesById(sessionId: string): string[] {
+    if (!isSafePathSegment(sessionId)) return [];
+
+    return this.collectJsonlFiles(this.sessionsDir).filter((filePath) => {
+      const basename = path.basename(filePath, ".jsonl");
+      return basename === sessionId || basename.endsWith(`_${sessionId}`);
+    });
+  }
+
   private buildProjectDirCwdMap(processes: ProcessInfo[]): Map<string, string> {
     const map = new Map<string, string>();
     for (const proc of processes) {

package/src/readiness/AgentReadiness.ts

@@ -12,7 +12,10 @@ const ANSI_ESCAPE_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]
 
 export type ReadinessStatus = "pass" | "warn" | "fail";
 export type ReadinessAuthState = "authenticated" | "unauthenticated" | "unknown";
-export type ReadinessAgentType = Exclude<StartableAgentType, "gemini_cli">;
+export type ReadinessAgentType = Exclude<
+  StartableAgentType,
+  "gemini_cli" | "kiro" | "antigravity_cli"
+>;
 type ReadinessInfoStatus = ReadinessStatus | "info";
 
 type CommandResult = { stdout: string; stderr: string };

package/src/runtime/ManagedAgentRuntime.ts

@@ -260,7 +260,9 @@ function agentRuntimeKind(type: StartableAgentType, provider: AgentRuntimeProvid
     copilot: "copilot",
     gemini_cli: "gemini",
     grok_cli: "grok",
+    antigravity_cli: "agy",
     opencode: "opencode",
     pi: "pi",
+    kiro: "kiro",
   }[type];
 }