@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/harnesses/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 { homeDir } from "../shared.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.
+    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/harnesses/grok/GrokSessionParser.ts

@@ -0,0 +1,251 @@
+import * as path from "path";
+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 } from "../shared.js";
+
+export const CHAT_HISTORY_FILE = "chat_history.jsonl";
+
+/** One line of chat_history.jsonl. */
+interface ChatRecord {
+  type?: string;
+  content?: unknown;
+}
+
+/**
+ * O(1) running summary folded from chat records: only the first/last real
+ * prompt and the role of the last user/assistant turn, never the turns.
+ */
+interface GrokSummaryState {
+  /** A bounded cold start skipped the middle: later lines are not the session's first. */
+  pastHead?: boolean;
+  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 interface GrokSessionParserOptions {
+  /** Cold-start scan bounds for `readSessionIncremental` (see IncrementalJsonlSummary). */
+  summaryBounds?: JsonlSummaryBounds | false;
+}
+
+export class GrokSessionParser {
+  /** Incremental reader backing `getConversation({ tail })`. */
+  private readonly tailReader = new JsonlTailReader();
+
+  private readonly sessionCache: IncrementalJsonlSummary<GrokSummaryState>;
+
+  constructor(options: GrokSessionParserOptions = {}) {
+    this.sessionCache = new IncrementalJsonlSummary(this.summaryReducer, {
+      bounds: options.summaryBounds,
+    });
+  }
+
+  /**
+   * 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 content = safeReadFile(chatPath);
+    const state = content === undefined ? {} : reduceJsonlContent(this.summaryReducer, content);
+    return this.toSession(sessionDir, defaultCwd, chatPath, chatStat.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`); fields whose entries lie only in the skipped
+   * middle fall back to their defaults instead of forcing a full parse.
+   */
+  readSessionIncremental(sessionDir: string, defaultCwd: string): GrokSession | null {
+    const chatPath = path.join(sessionDir, CHAT_HISTORY_FILE);
+    const result = this.sessionCache.read(chatPath);
+    if (result) {
+      return this.toSession(sessionDir, defaultCwd, chatPath, result.mtime, result.state);
+    }
+    // Present but unreadable: surface the session without a summary, like readSession.
+    const chatStat = safeStat(chatPath);
+    return chatStat ? this.toSession(sessionDir, defaultCwd, chatPath, chatStat.mtime, {}) : null;
+  }
+
+  /** Evict cached summaries for files not read since the previous prune. */
+  pruneSessionCache(): void {
+    this.sessionCache.prune();
+  }
+
+  /** Accepts a session dir or an explicit chat_history.jsonl path. */
+  getConversation(sessionPath: string, options?: ConversationOptions): ConversationMessage[] {
+    const chatPath = this.resolveChatPath(sessionPath);
+    const verbose = options?.verbose ?? false;
+    const tail = normalizeTail(options?.tail);
+    if (tail !== undefined) {
+      return this.tailReader.read(
+        chatPath,
+        tail,
+        { parseLine: (line) => this.lineToMessage(line, verbose) },
+        String(verbose),
+      );
+    }
+    return this.parseChatHistory(chatPath, verbose);
+  }
+
+  /**
+   * 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 {
+    if (isIdle(session.lastActive)) {
+      return AgentStatus.IDLE;
+    }
+    if (session.lastRole === "assistant") {
+      return AgentStatus.WAITING;
+    }
+    return AgentStatus.RUNNING;
+  }
+
+  /**
+   * Fold one chat_history.jsonl entry into the O(1) summary. Uses the same
+   * record rules as `getConversation` (see `toMessage`), minus system records.
+   *
+   * `skip` (bounded cold start) keeps the head's first user message and
+   * clears the last user message and last role, so those come from the tail
+   * only. A first user message beyond the head stays undefined rather than
+   * being filled from the tail; latest fields before the tail window stay
+   * undefined.
+   */
+  private readonly summaryReducer: JsonlSummaryReducer<GrokSummaryState> = {
+    initial: () => ({}),
+    reduce: (state, value) => {
+      const message = this.toMessage(value, false);
+      if (!message) return state;
+      if (message.role === "user") {
+        return {
+          ...state,
+          firstUserMessage:
+            state.firstUserMessage ?? (state.pastHead ? undefined : message.content),
+          lastUserMessage: message.content,
+          lastRole: "user",
+        };
+      }
+      return { ...state, lastRole: message.role };
+    },
+    skip: (state) => ({ pastHead: true, firstUserMessage: state.firstUserMessage }),
+  };
+
+  private toSession(
+    sessionDir: string,
+    defaultCwd: string,
+    chatPath: string,
+    lastActive: Date,
+    state: GrokSummaryState,
+  ): GrokSession {
+    const dirStat = safeStat(sessionDir);
+    return {
+      sessionId: path.basename(sessionDir),
+      projectPath: defaultCwd,
+      sessionFilePath: chatPath,
+      sessionStart: dirStat?.birthtime || lastActive,
+      lastActive,
+      firstUserMessage: state.firstUserMessage,
+      lastUserMessage: state.lastUserMessage,
+      lastRole: state.lastRole,
+    };
+  }
+
+  /** Full pass over chat_history.jsonl building every conversation turn. */
+  private parseChatHistory(chatPath: string, verbose: boolean): ConversationMessage[] {
+    const content = safeReadFile(chatPath);
+    if (content === undefined) return [];
+
+    const messages: ConversationMessage[] = [];
+    for (const line of content.trim().split("\n")) {
+      const message = this.lineToMessage(line, verbose);
+      if (message) messages.push(message);
+    }
+    return messages;
+  }
+
+  /**
+   * Map one parsed chat record to a conversation turn, or null to skip it.
+   * Each record is a { type: 'system' | 'user' | 'assistant', content } object
+   * 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 toMessage(value: unknown, verbose: boolean): ConversationMessage | null {
+    if (!value || typeof value !== "object") return null;
+    const record = value as ChatRecord;
+
+    const text = flattenTextBlocks(record.content);
+    if (record.type === "user") {
+      const query = this.extractUserQuery(text);
+      return query === null ? null : { role: "user", content: query };
+    }
+    if (record.type === "assistant") {
+      return text ? { role: "assistant", content: text } : null;
+    }
+    if (verbose && record.type === "system") {
+      return text ? { role: "system", content: text } : null;
+    }
+    return null;
+  }
+
+  /** Convert one chat_history.jsonl line into a message, or null when it is not one. */
+  private lineToMessage(line: string, verbose: boolean): ConversationMessage | null {
+    if (!line.trim()) return null;
+
+    let record: unknown;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    return this.toMessage(record, verbose);
+  }
+
+  /**
+   * 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/harnesses/index.ts

@@ -0,0 +1,28 @@
+import type { AgentAdapter } from "../adapters/AgentAdapter.js";
+import { AntigravityCliAdapter } from "./antigravity/AntigravityCliAdapter.js";
+import { ClaudeCodeAdapter } from "./claude/ClaudeCodeAdapter.js";
+import { CodexAdapter } from "./codex/CodexAdapter.js";
+import { CopilotAdapter } from "./copilot/CopilotAdapter.js";
+import { GeminiCliAdapter } from "./gemini/GeminiCliAdapter.js";
+import { GrokCliAdapter } from "./grok/GrokCliAdapter.js";
+import { KiroAdapter } from "./kiro/KiroAdapter.js";
+import { OpenCodeAdapter } from "./opencode/OpenCodeAdapter.js";
+import { PiAdapter } from "./pi/PiAdapter.js";
+
+/**
+ * One instance of every built-in harness adapter, in registration order
+ * (which is also the order agents are listed in). Register a new harness here.
+ */
+export function createBuiltinAdapters(): AgentAdapter[] {
+  return [
+    new ClaudeCodeAdapter(),
+    new CodexAdapter(),
+    new CopilotAdapter(),
+    new GeminiCliAdapter(),
+    new GrokCliAdapter(),
+    new KiroAdapter(),
+    new AntigravityCliAdapter(),
+    new OpenCodeAdapter(),
+    new PiAdapter(),
+  ];
+}

package/src/harnesses/kiro/KiroAdapter.ts

@@ -0,0 +1,143 @@
+import * as path from "path";
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  ConversationOptions,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import { executablePath } from "../../utils/process.js";
+import { findHarnessProcesses } from "../shared.js";
+import { KiroAgentMapper } from "./KiroAgentMapper.js";
+import { KiroSessionLocator } from "./KiroSessionLocator.js";
+import { KiroSessionParser, type KiroSession } from "./KiroSessionParser.js";
+
+const KIRO_BASENAMES = new Set(["kiro-cli", "kiro"]);
+const SCRIPT_RUNTIMES = new Set(["node", "bun"]);
+
+/**
+ * Kiro Adapter
+ *
+ * Detects running Kiro agents by matching the PID in each
+ * ~/.kiro/sessions/cli/<session-id>.lock to a running Kiro process (walking up
+ * from helper processes such as `kiro-cli-chat acp`), then reading the sibling
+ * <session-id>.json metadata and <session-id>.jsonl transcript.
+ */
+export class KiroAdapter implements AgentAdapter {
+  readonly type = "kiro" as const;
+  /**
+   * Also collects the helpers between a lock holder and its kiro-cli, such as
+   * the bundled `bun … tui.js`; `canHandle` still decides which are agents.
+   */
+  readonly processNames = ["kiro-cli", "kiro", "kiro-cli-chat", "node", "bun"] as const;
+
+  private parser: KiroSessionParser;
+  private mapper: KiroAgentMapper;
+  private locator: KiroSessionLocator;
+
+  constructor() {
+    this.parser = new KiroSessionParser();
+    this.mapper = new KiroAgentMapper(this.parser);
+    this.locator = new KiroSessionLocator();
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return this.isKiroExecutable(processInfo.command);
+  }
+
+  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 { relevant, processes } = await findHarnessProcesses(this, context);
+    if (processes.length === 0) return [];
+
+    const agents: AgentInfo[] = [];
+    const matchedPids = new Set<number>();
+    for (const match of this.locator.matchRunningProcesses(relevant, processes, (process) =>
+      this.canHandle(process),
+    )) {
+      const session = this.parser.readSessionIncremental(match.session, match.process.cwd);
+      if (!session) continue;
+
+      agents.push(this.mapper.mapSessionToAgent({ session, processInfo: match.process }));
+      matchedPids.add(match.process.pid);
+    }
+
+    for (const proc of processes) {
+      if (!matchedPids.has(proc.pid)) {
+        agents.push(this.mapper.mapProcessOnlyAgent(proc));
+      }
+    }
+    return agents;
+  }
+
+  getConversation(sessionFilePath: string, options?: ConversationOptions): ConversationMessage[] {
+    return this.parser.getConversation(sessionFilePath, options);
+  }
+
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    const summaries: SessionSummary[] = [];
+    for (const paths of this.locator.listSessions()) {
+      const session = this.parser.readSession(paths);
+      if (!session) continue;
+      if (opts?.cwd !== undefined && session.projectPath !== opts.cwd) continue;
+
+      summaries.push(this.toSessionSummary(session));
+    }
+    return summaries;
+  }
+
+  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {
+    const paths = this.locator.findSession(sessionId);
+    const session = paths ? this.parser.readSession(paths) : null;
+    // listSessions reports the metadata's id, so only an exact match counts.
+    return session?.sessionId === sessionId ? [this.toSessionSummary(session)] : [];
+  }
+
+  private toSessionSummary(session: KiroSession): SessionSummary {
+    return {
+      type: this.type,
+      sessionId: session.sessionId,
+      cwd: session.projectPath,
+      firstUserMessage: session.firstUserMessage,
+      lastActive: session.lastActive,
+      startedAt: session.sessionStart,
+      sessionFilePath: session.sessionFilePath,
+    };
+  }
+
+  /** `kiro-cli` / `kiro`, directly or as a script run by node or bun. */
+  private isKiroExecutable(command: string): boolean {
+    const trimmed = command.trim();
+    const executable = executablePath(trimmed);
+    if (!executable) return false;
+
+    const executableName = kiroBasename(executable);
+    if (KIRO_BASENAMES.has(executableName)) return true;
+    if (!SCRIPT_RUNTIMES.has(executableName)) return false;
+
+    const args = trimmed.slice(executable.length).trim().split(/\s+/);
+    const scriptIndex = args.findIndex((token) => token !== "" && !token.startsWith("-"));
+    if (scriptIndex === -1) return false;
+    // The script path may also contain spaces; resolve it like argv[0].
+    const script = executablePath(args.slice(scriptIndex).join(" "));
+    return KIRO_BASENAMES.has(kiroBasename(script));
+  }
+}
+
+function kiroBasename(executable: string): string {
+  return path
+    .basename(executable.replace(/\\/g, "/"))
+    .toLowerCase()
+    .replace(/\.(exe|js)$/, "");
+}

package/src/harnesses/kiro/KiroAgentMapper.ts

@@ -0,0 +1,34 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import { processOnlyAgent, SUMMARY_MAX_LENGTH, truncate } from "../shared.js";
+import { KiroSessionParser, type KiroSession } from "./KiroSessionParser.js";
+
+export interface KiroSessionAgentInput {
+  session: KiroSession;
+  processInfo: ProcessInfo;
+}
+
+export class KiroAgentMapper {
+  constructor(private readonly parser: KiroSessionParser = new KiroSessionParser()) {}
+
+  mapSessionToAgent({ session, processInfo }: KiroSessionAgentInput): AgentInfo {
+    return {
+      name: generateAgentName(session.projectPath, processInfo.pid),
+      type: "kiro",
+      status: this.parser.determineStatus(session),
+      summary: truncate(
+        session.lastUserMessage || session.title || "Kiro session active",
+        SUMMARY_MAX_LENGTH,
+      ),
+      pid: processInfo.pid,
+      projectPath: session.projectPath,
+      sessionId: session.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: session.sessionFilePath,
+    };
+  }
+
+  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
+    return processOnlyAgent("kiro", processInfo, { summary: "Kiro process running" });
+  }
+}