@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/harnesses/runtimeProfiles.ts

@@ -0,0 +1,103 @@
+import path from "node:path";
+import { AGENT_TYPES, type AgentType } from "../adapters/AgentAdapter.js";
+import { executablePath } from "../utils/process.js";
+
+export type StartableAgentType = (typeof AGENT_TYPES)[number];
+
+export interface HarnessRuntimeProfile {
+  command: string;
+  runtimeKind: string;
+  discoveryAliases: readonly string[];
+  matches: (psCommand: string) => boolean;
+}
+
+export const HARNESS_RUNTIME_PROFILES: Record<StartableAgentType, HarnessRuntimeProfile> = {
+  claude: profile("claude", matchArgv0("claude")),
+  codex: profile("codex", matchArgv0("codex")),
+  copilot: profile("copilot", matchArgv0Name("copilot-cli")),
+  gemini_cli: profile("gemini", matchAnyBasename(["gemini"]), ["gemini_cli"]),
+  grok_cli: profile("grok", matchArgv0("grok"), ["grok_cli"]),
+  antigravity_cli: profile("agy", matchArgv0("agy"), ["antigravity", "antigravity_cli"]),
+  opencode: profile("opencode", matchArgv0("opencode")),
+  pi: profile("pi", matchAnyBasename(["pi"])),
+  kiro: profile("kiro", matchAnyBasename(["kiro-cli", "kiro"]), ["kiro_cli", "kiro-cli"]),
+};
+
+export function runtimeAgentMatchesHarness(runtimeAgent: string, type: AgentType): boolean {
+  if (type === "other") return runtimeAgent.toLowerCase() === "other";
+  return HARNESS_RUNTIME_PROFILES[type].discoveryAliases.includes(runtimeAgent.toLowerCase());
+}
+
+function profile(
+  runtimeKind: string,
+  matches: (psCommand: string) => boolean,
+  extraAliases: readonly string[] = [],
+): HarnessRuntimeProfile {
+  return {
+    command: runtimeKind === "kiro" ? "kiro-cli" : runtimeKind,
+    runtimeKind,
+    discoveryAliases: [runtimeKind, ...extraAliases],
+    matches,
+  };
+}
+
+const ABSOLUTE_PATH = /^(?:\/|[a-zA-Z]:[\\/])/;
+const PATH_SEPARATOR = /[\\/]/;
+
+function basenameOf(token: string): string {
+  return path.basename(token).toLowerCase();
+}
+
+function tokensOf(psCommand: string): string[] {
+  return psCommand.trim().split(/\s+/).filter(Boolean);
+}
+
+function splitArgv0(psCommand: string): { argv0: string; args: string[] } {
+  const command = psCommand.trim();
+  const argv0 = executablePath(command);
+  return { argv0, args: tokensOf(command.slice(argv0.length)) };
+}
+
+function mayContinueArgv0(tokens: string[], test: (token: string) => boolean): boolean {
+  return (
+    ABSOLUTE_PATH.test(tokens[0]) &&
+    tokens.slice(1).some((token) => PATH_SEPARATOR.test(token) && test(token))
+  );
+}
+
+function matchArgv0(name: string): (psCommand: string) => boolean {
+  const lower = name.toLowerCase();
+  const test = (token: string) => basenameOf(token) === lower;
+  return (psCommand) => {
+    const tokens = tokensOf(psCommand);
+    if (tokens.length === 0) return false;
+    if (test(tokens[0])) return true;
+    return mayContinueArgv0(tokens, test) && test(executablePath(psCommand));
+  };
+}
+
+function matchArgv0Name(name: string): (psCommand: string) => boolean {
+  const lower = name.toLowerCase();
+  const test = (token: string) => token.toLowerCase().includes(lower);
+  return (psCommand) => {
+    const tokens = tokensOf(psCommand);
+    if (tokens.length === 0) return false;
+    if (test(tokens[0])) return true;
+    return mayContinueArgv0(tokens, test) && test(executablePath(psCommand));
+  };
+}
+
+function matchAnyBasename(names: string[]): (psCommand: string) => boolean {
+  const lowers = new Set(names.map((name) => name.toLowerCase()));
+  const test = (token: string) => lowers.has(basenameOf(token));
+  return (psCommand) => {
+    const tokens = tokensOf(psCommand);
+    if (tokens.length === 0) return false;
+    if (test(tokens[0])) return true;
+    if (!tokens.slice(1).some(test)) return false;
+    if (!ABSOLUTE_PATH.test(tokens[0])) return true;
+
+    const { argv0, args } = splitArgv0(psCommand);
+    return test(argv0) || args.some(test);
+  };
+}

package/src/harnesses/shared.ts

@@ -0,0 +1,119 @@
+/**
+ * Helpers shared by the harness adapters. Each harness keeps its own session
+ * matching and parsing; these cover the parts that are the same everywhere.
+ */
+
+import type {
+  AgentAdapter,
+  AgentDetectionContext,
+  AgentInfo,
+  AgentType,
+  ProcessInfo,
+} from "../adapters/AgentAdapter.js";
+import { AgentStatus } from "../adapters/AgentAdapter.js";
+import { generateAgentName } from "../utils/matching.js";
+import {
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+} from "../utils/process.js";
+
+/** A session untouched for longer than this is IDLE. */
+export const IDLE_THRESHOLD_MINUTES = 5;
+
+/** Maximum length of a session summary derived from a user prompt. */
+export const SUMMARY_MAX_LENGTH = 120;
+
+export interface HarnessProcesses {
+  /** Every process whose executable is one of the adapter's `processNames`. */
+  relevant: ProcessInfo[];
+  /** The subset `canHandle` accepts (deduplicated by PID): the agents. */
+  processes: ProcessInfo[];
+}
+
+/**
+ * The adapter's processes from the manager's shared snapshot, or from its own
+ * capture when called standalone. `relevant` also keeps helper processes
+ * (e.g. a harness's child runtime) that detection may need to walk through.
+ */
+export async function findHarnessProcesses(
+  adapter: Pick<AgentAdapter, "canHandle"> & { readonly processNames: readonly string[] },
+  context?: AgentDetectionContext,
+): Promise<HarnessProcesses> {
+  const snapshot =
+    context?.processes ??
+    (await captureProcessSnapshot(adapter.processNames, {
+      isCandidate: (process) => adapter.canHandle(process),
+    }));
+  const relevant = filterByProcessNames(snapshot, adapter.processNames);
+
+  const byPid = new Map<number, ProcessInfo>();
+  for (const process of relevant) {
+    if (!byPid.has(process.pid) && adapter.canHandle(process)) byPid.set(process.pid, process);
+  }
+  return { relevant, processes: Array.from(byPid.values()) };
+}
+
+/** Whether argv[0]'s basename is `name` or `name.exe`. */
+export function matchesExecutable(command: string, name: string): boolean {
+  const base = executableBasename(command);
+  return base === name || base === `${name}.exe`;
+}
+
+/**
+ * The placeholder agent for a running process with no matched session:
+ * RUNNING, with a `pid-<pid>` session id.
+ */
+export function processOnlyAgent(
+  type: AgentType,
+  processInfo: ProcessInfo,
+  { summary, cwd = processInfo.cwd }: { summary: string; cwd?: string },
+): AgentInfo {
+  return {
+    name: generateAgentName(cwd, processInfo.pid),
+    type,
+    status: AgentStatus.RUNNING,
+    summary,
+    pid: processInfo.pid,
+    projectPath: cwd,
+    sessionId: `pid-${processInfo.pid}`,
+    lastActive: new Date(),
+  };
+}
+
+export function isIdle(lastActive: Date, now = Date.now()): boolean {
+  return (now - lastActive.getTime()) / 60000 > IDLE_THRESHOLD_MINUTES;
+}
+
+export function homeDir(): string {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+
+/** ISO strings, or epoch numbers in seconds or milliseconds; null when invalid. */
+export function parseTimestamp(value: unknown): Date | null {
+  if (typeof value === "number") {
+    const date = new Date(value < 1_000_000_000_000 ? value * 1000 : value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  if (typeof value !== "string" || !value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+export function truncate(value: string, maxLength: number): string {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 3)}...`;
+}
+
+/** Flatten a string, or an array of `{ text }` blocks, to plain text. */
+export function flattenTextBlocks(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) =>
+      block && typeof block === "object" && typeof (block as { text?: unknown }).text === "string"
+        ? (block as { text: string }).text
+        : "",
+    )
+    .join("");
+}

package/src/index.ts

@@ -1,71 +1,41 @@
-export { AgentManager, AgentNotRunningError } from "./AgentManager.js";
+export { AgentManager } from "./AgentManager.js";
 export {
+  getAnthropicCapacityReport,
   getClaudeCapacityReport,
   getCodexCapacityReport,
   getOpenAiCapacityReport,
   getZaiCapacityReport,
 } from "./capacity/index.js";
-export type {
-  ClaudeCapacityOptions,
-  CapacityProbeOptions,
-  CapacityReport,
-  CapacityWindow,
-  OpenAiCapacityOptions,
-  ZaiCapacityOptions,
-} from "./capacity/index.js";
+export type { CapacityReport, CapacityWindow } from "./capacity/index.js";
+
 export {
-  getAgentReadinessReport,
   getAgentReadinessReports,
   worstReadinessStatus,
-} from "./readiness/AgentReadiness.js";
+} from "./harnesses/readiness/AgentReadiness.js";
 export type {
   AgentReadinessOptions,
   AgentReadinessReport,
-  AuthReadinessCheck,
-  BuiltInSkillsReadinessCheck,
-  DirectoryReadinessCheck,
-  ExecutableReadinessCheck,
-  IntegrationReadinessCheck,
   ReadinessAgentType,
-  ReadinessAuthState,
-  ReadinessCheck,
   ReadinessStatus,
-} from "./readiness/AgentReadiness.js";
+} from "./harnesses/readiness/AgentReadiness.js";
 
-export { ClaudeCodeAdapter } from "./providers/claude/ClaudeCodeAdapter.js";
-export { CodexAdapter } from "./providers/codex/CodexAdapter.js";
-export { CopilotAdapter } from "./providers/copilot/CopilotAdapter.js";
-export { GeminiCliAdapter } from "./providers/gemini/GeminiCliAdapter.js";
-export { GrokCliAdapter } from "./providers/grok/GrokCliAdapter.js";
-export { AntigravityCliAdapter } from "./adapters/AntigravityCliAdapter.js";
-export { KiroAdapter } from "./adapters/KiroAdapter.js";
-export { OpenCodeAdapter } from "./providers/opencode/OpenCodeAdapter.js";
-export { PiAdapter } from "./providers/pi/PiAdapter.js";
-export { AgentStatus } from "./adapters/AgentAdapter.js";
+export { createBuiltinAdapters } from "./harnesses/index.js";
+export { HARNESS_RUNTIME_PROFILES, type StartableAgentType } from "./harnesses/runtimeProfiles.js";
+export { AGENT_TYPES, AgentStatus } from "./adapters/AgentAdapter.js";
 export type {
   AgentAdapter,
   AgentType,
   AgentInfo,
-  ProcessInfo,
   ConversationMessage,
   SessionSummary,
   ListSessionsOptions,
-  AgentDetectionContext,
 } from "./adapters/AgentAdapter.js";
 
-export { TerminalFocusManager, TerminalType } from "./terminal/TerminalFocusManager.js";
-export type { TerminalLocation } from "./terminal/TerminalFocusManager.js";
+export { TerminalFocusManager } from "./terminal/TerminalFocusManager.js";
+export { TerminalType } from "./terminal/types.js";
+export type { TerminalLocation } from "./terminal/types.js";
 export { TtyWriter } from "./terminal/TtyWriter.js";
 
-export type { AgentManagerOptions, ListAgentsOptions } from "./AgentManager.js";
-export {
-  extractHerdrAgentPanes,
-  fetchHerdrAgentPanes,
-  findMatchingHerdrPane,
-  herdrPaneToRuntimeRef,
-} from "./runtime/herdr/HerdrAgentDiscovery.js";
-export type { HerdrAgentPane } from "./runtime/herdr/HerdrAgentDiscovery.js";
-
 export {
   AgentRegistry,
   RenameNotFoundError,
@@ -73,14 +43,8 @@ export {
   AGENT_RUNTIME_PROVIDERS,
   parseTmuxRuntimeRef,
 } from "./utils/AgentRegistry.js";
-export type {
-  AgentRegistryOptions,
-  RegistryEntry,
-  AgentRuntimeProvider,
-  TmuxRuntimeRef,
-} from "./utils/AgentRegistry.js";
-export { TmuxManager } from "./terminal/TmuxManager.js";
-export type { AgentRuntimeAvailability, InteractiveAgentRuntime } from "./runtime/types.js";
+export type { AgentRuntimeProvider } from "./utils/AgentRegistry.js";
+export type { InteractiveAgentRuntime } from "./runtime/types.js";
 export {
   startAgent,
   stopAgent,
@@ -91,90 +55,15 @@ export {
   AgentPidPollTimeoutError,
   AgentRuntimeUnavailableError,
   AgentTerminalNotFoundError,
-  DEFAULT_PID_POLL_INTERVAL_MS,
   DEFAULT_PID_POLL_TIMEOUT_MS,
 } from "./runtime/ManagedAgentRuntime.js";
-export type {
-  FocusAgentDeps,
-  StartAgentDeps,
-  StartAgentOptions,
-  StopAgentDeps,
-  StopAgentResult,
-  FocusAgentResult,
-  SendAgentPromptDeps,
-} from "./runtime/ManagedAgentRuntime.js";
-export { AGENTS } from "./utils/agents.js";
-export type { AgentConfig, StartableAgentType } from "./utils/agents.js";
 
 export type { AgentRequest } from "./utils/agent-requests.js";
-export {
-  getAgentRequestPath,
-  readLatestAgentRequest,
-  writeAgentRequest,
-} from "./utils/agent-requests.js";
+export { readLatestAgentRequest, writeAgentRequest } from "./utils/agent-requests.js";
 
-export {
-  AGENT_MODES,
-  DurableAgentError,
-  DurableAgentBusyError,
-  DurableAgentNotFoundError,
-  DurableAgentRepositoryError,
-  DurableAgentNameConflictError,
-  ClaudePrintError,
-  CodexPrintError,
-  PiPrintError,
-} from "./durable/DurableAgent.js";
-export type {
-  DurableAgent,
-  DurableAgentBase,
-  ClaudeDurableAgent,
-  CodexDurableAgent,
-  PiDurableAgent,
-  DurableProvider,
-  CodexPrintErrorCode,
-  DurableAgentState,
-  DurableSessionHealth,
-  DurableRunStatus,
-  DurableActiveRun,
-  DurableLastResult,
-  PiPrintErrorCode,
-  ProcessIdentity,
-} from "./durable/DurableAgent.js";
+export { AGENT_MODES } from "./durable/DurableAgent.js";
+export type { DurableProvider } from "./durable/DurableAgent.js";
 export { DurableAgentRepository } from "./durable/DurableAgentRepository.js";
-export type {
-  CreateDurableAgentInput,
-  DurableAgentRepositoryOptions,
-  ProcessInspector,
-  DurableRunCompletion,
-} from "./durable/DurableAgentRepository.js";
-export { ClaudePrintAgentService } from "./providers/claude/durable/ClaudePrintAgentService.js";
-export type {
-  ClaudePrintAgentServiceOptions,
-  ClaudePrintSendResult,
-} from "./providers/claude/durable/ClaudePrintAgentService.js";
-export { CodexCliProbe } from "./providers/codex/durable/CodexCliProbe.js";
-export type { CodexCliProbeOptions } from "./providers/codex/durable/CodexCliProbe.js";
-export { CodexPrintRunner } from "./providers/codex/durable/CodexPrintRunner.js";
-export type {
-  CodexPrintRunnerOptions,
-  CodexPrintRunRequest,
-  CodexPrintRunResult,
-} from "./providers/codex/durable/CodexPrintRunner.js";
-export { CodexPrintAgentService } from "./providers/codex/durable/CodexPrintAgentService.js";
-export type {
-  CodexPrintAgentServiceOptions,
-  CodexPrintSendResult,
-} from "./providers/codex/durable/CodexPrintAgentService.js";
-export { PiCliProbe } from "./providers/pi/durable/PiCliProbe.js";
-export type { PiCliProbeOptions } from "./providers/pi/durable/PiCliProbe.js";
-export { PiPrintRunner } from "./providers/pi/durable/PiPrintRunner.js";
-export type {
-  PiPrintRunnerOptions,
-  PiPrintRunRequest,
-  PiPrintRunResult,
-} from "./providers/pi/durable/PiPrintRunner.js";
-export { PiPrintAgentService } from "./providers/pi/durable/PiPrintAgentService.js";
-export type {
-  PiPrintAgentServiceOptions,
-  PiPrintSendResult,
-} from "./providers/pi/durable/PiPrintAgentService.js";
+export { ClaudePrintAgentService } from "./harnesses/claude/durable/ClaudePrintAgentService.js";
+export { CodexPrintAgentService } from "./harnesses/codex/durable/CodexPrintAgentService.js";
+export { PiPrintAgentService } from "./harnesses/pi/durable/PiPrintAgentService.js";

package/src/runtime/ManagedAgentRuntime.ts

@@ -1,12 +1,12 @@
 import type { AgentInfo } from "../adapters/AgentAdapter.js";
-import type { TerminalLocation } from "../terminal/TerminalFocusManager.js";
-import { TmuxManager } from "../terminal/TmuxManager.js";
+import type { TerminalLocation } from "../terminal/types.js";
+import { TmuxManager } from "./tmux/TmuxManager.js";
 import {
   AgentRegistry,
   type AgentRuntimeProvider,
   type RegistryEntry,
 } from "../utils/AgentRegistry.js";
-import { AGENTS, type StartableAgentType } from "../utils/agents.js";
+import { HARNESS_RUNTIME_PROFILES, type StartableAgentType } from "../harnesses/runtimeProfiles.js";
 import { createInteractiveRuntime } from "./RuntimeFactory.js";
 import { DEFAULT_PID_POLL_INTERVAL_MS, DEFAULT_PID_POLL_TIMEOUT_MS } from "./tmux/PidPolling.js";
 import { TmuxAgentRuntime } from "./tmux/TmuxAgentRuntime.js";
@@ -91,7 +91,7 @@ export async function startAgent(
   deps: StartAgentDeps = {},
 ): Promise<RegistryEntry> {
   const registry = deps.registry ?? AgentRegistry.default();
-  const agent = AGENTS[opts.type];
+  const profile = HARNESS_RUNTIME_PROFILES[opts.type];
   const intervalMs = opts.pollIntervalMs ?? DEFAULT_PID_POLL_INTERVAL_MS;
   const timeoutMs = opts.pollTimeoutMs ?? DEFAULT_PID_POLL_TIMEOUT_MS;
   const provider = opts.runtimeProvider ?? deps.runtime?.provider ?? "tmux";
@@ -119,13 +119,13 @@ export async function startAgent(
   const result = await runtime.startAgent({
     name: opts.name,
     cwd: opts.cwd,
-    kind: agentRuntimeKind(opts.type, provider),
+    kind: profile.runtimeKind,
     args: [],
     timeoutMs,
     ...(provider === "tmux"
       ? {
-          command: agent.command,
-          matches: agent.matches,
+          command: profile.command,
+          matches: profile.matches,
           pollIntervalMs: intervalMs,
         }
       : {}),
@@ -251,18 +251,3 @@ function isHerdrRegistryEntry(
     "runtimeRef" in entry
   );
 }
-
-function agentRuntimeKind(type: StartableAgentType, provider: AgentRuntimeProvider): string {
-  if (provider === "tmux") return type;
-  return {
-    claude: "claude",
-    codex: "codex",
-    copilot: "copilot",
-    gemini_cli: "gemini",
-    grok_cli: "grok",
-    antigravity_cli: "agy",
-    opencode: "opencode",
-    pi: "pi",
-    kiro: "kiro",
-  }[type];
-}

package/src/runtime/herdr/HerdrAgentDiscovery.ts

@@ -1,4 +1,5 @@
-import type { AgentInfo, AgentType } from "../../adapters/AgentAdapter.js";
+import type { AgentInfo } from "../../adapters/AgentAdapter.js";
+import { runtimeAgentMatchesHarness } from "../../harnesses/runtimeProfiles.js";
 import { HerdrCliClient, type HerdrCommandRunner } from "./HerdrCliClient.js";
 import type { HerdrRuntimeRef } from "./HerdrRuntimeRef.js";
 
@@ -70,7 +71,7 @@ export function findMatchingHerdrPane(
   if (shellPidMatches.length > 1) return null;
 
   const cwdMatches = panes.filter(
-    (pane) => pane.cwd === agent.projectPath && herdrAgentMatchesType(pane.agent, agent.type),
+    (pane) => pane.cwd === agent.projectPath && runtimeAgentMatchesHarness(pane.agent, agent.type),
   );
   return cwdMatches.length === 1 ? cwdMatches[0]! : null;
 }
@@ -85,23 +86,6 @@ export function herdrPaneToRuntimeRef(pane: HerdrAgentPane, agentName: string):
   };
 }
 
-function herdrAgentMatchesType(herdrAgent: string, agentType: AgentType): boolean {
-  const normalized = herdrAgent.toLowerCase();
-  const candidates: Record<AgentType, readonly string[]> = {
-    claude: ["claude"],
-    codex: ["codex"],
-    copilot: ["copilot"],
-    gemini_cli: ["gemini", "gemini_cli"],
-    grok_cli: ["grok", "grok_cli"],
-    antigravity_cli: ["agy", "antigravity", "antigravity_cli"],
-    kiro: ["kiro", "kiro_cli", "kiro-cli"],
-    opencode: ["opencode"],
-    pi: ["pi"],
-    other: ["other"],
-  };
-  return candidates[agentType]?.includes(normalized) ?? false;
-}
-
 async function enrichHerdrAgentPanes(
   client: HerdrCliClient,
   panes: HerdrAgentPane[],

package/src/runtime/tmux/PidPolling.ts

@@ -1,4 +1,4 @@
-import type { TmuxManager } from "../../terminal/TmuxManager.js";
+import type { TmuxManager } from "./TmuxManager.js";
 
 export const DEFAULT_PID_POLL_INTERVAL_MS = 500;
 export const DEFAULT_PID_POLL_TIMEOUT_MS = 15_000;

package/src/runtime/tmux/TmuxAgentRuntime.ts

@@ -1,4 +1,4 @@
-import { TmuxManager } from "../../terminal/TmuxManager.js";
+import { TmuxManager } from "./TmuxManager.js";
 import { TtyWriter } from "../../terminal/TtyWriter.js";
 import { AgentPidPollTimeoutError, AgentTerminalNotFoundError } from "../errors.js";
 import { pollForPid } from "./PidPolling.js";

package/src/runtime/tmux/TmuxManager.ts

@@ -0,0 +1,102 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export class TmuxManager {
+  async isAvailable(): Promise<boolean> {
+    try {
+      await execFileAsync("tmux", ["-V"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async sessionExists(name: string): Promise<boolean> {
+    try {
+      await execFileAsync("tmux", ["has-session", "-t", name]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async createSession(name: string, cwd: string): Promise<void> {
+    await execFileAsync("tmux", ["new-session", "-d", "-s", name, "-c", cwd]);
+  }
+
+  async sendKeys(session: string, keys: string): Promise<void> {
+    await execFileAsync("tmux", ["send-keys", "-t", session, keys, "Enter"]);
+  }
+
+  async killSession(name: string): Promise<void> {
+    try {
+      await execFileAsync("tmux", ["kill-session", "-t", name]);
+    } catch {
+      // Already gone — ignore
+    }
+  }
+
+  async findAgentPid(
+    session: string,
+    matches: (psCommand: string) => boolean,
+  ): Promise<number | null> {
+    const panePid = await this.getPanePid(session);
+    if (panePid === null) return null;
+
+    const visited = new Set<number>();
+    const queue: number[] = [panePid];
+    let deepestMatch: number | null = null;
+
+    while (queue.length > 0) {
+      const pid = queue.shift()!;
+      if (visited.has(pid)) continue;
+      visited.add(pid);
+
+      const command = await this.getProcessCommand(pid);
+      if (command && matches(command)) deepestMatch = pid;
+      queue.push(...(await this.pgrepChildren(pid)));
+    }
+
+    return deepestMatch;
+  }
+
+  private async getPanePid(session: string): Promise<number | null> {
+    try {
+      const { stdout } = await execFileAsync("tmux", [
+        "list-panes",
+        "-t",
+        session,
+        "-F",
+        "#{pane_pid}",
+      ]);
+      const panePid = Number.parseInt(stdout.trim().split("\n")[0], 10);
+      return Number.isNaN(panePid) ? null : panePid;
+    } catch {
+      return null;
+    }
+  }
+
+  private async pgrepChildren(pid: number): Promise<number[]> {
+    try {
+      const { stdout } = await execFileAsync("pgrep", ["-P", String(pid)]);
+      return stdout
+        .trim()
+        .split("\n")
+        .map((value) => Number.parseInt(value, 10))
+        .filter((value) => !Number.isNaN(value));
+    } catch {
+      return [];
+    }
+  }
+
+  private async getProcessCommand(pid: number): Promise<string | null> {
+    try {
+      const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "command="]);
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+}

package/src/runtime/types.ts

@@ -1,5 +1,5 @@
 import type { AgentInfo } from "../adapters/AgentAdapter.js";
-import type { TerminalLocation } from "../terminal/TerminalFocusManager.js";
+import type { TerminalLocation } from "../terminal/types.js";
 import type { AgentRuntimeProvider } from "../utils/AgentRegistry.js";
 
 export type AgentRuntimeAvailability =