@ai-devkit/agent-manager 0.32.0 → 0.33.1

package/src/providers/codex/durable/CodexPrintRunner.ts

@@ -1,94 +1,104 @@
-import { spawn as nodeSpawn, type ChildProcessWithoutNullStreams, type SpawnOptionsWithoutStdio } from 'child_process';
-import type { CodexDurableAgent, ProcessIdentity } from '../../../durable/DurableAgent.js';
-import { CodexPrintError } from '../../../durable/DurableAgent.js';
-import { LocalProcessInspector, type ProcessInspector } from '../../../durable/process.js';
-import { waitForChildClose } from '../../../durable/utils.js';
-import { CodexStreamParser } from './CodexStreamParser.js';
+import {
+  spawn as nodeSpawn,
+  type ChildProcessWithoutNullStreams,
+  type SpawnOptionsWithoutStdio,
+} from "child_process";
+import type { CodexDurableAgent, ProcessIdentity } from "../../../durable/DurableAgent.js";
+import { CodexPrintError } from "../../../durable/DurableAgent.js";
+import { LocalProcessInspector, type ProcessInspector } from "../../../durable/process.js";
+import { waitForChildClose } from "../../../durable/utils.js";
+import { CodexStreamParser } from "./CodexStreamParser.js";
 
 type Spawn = (
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithoutStdio & { stdio: ['pipe', 'pipe', 'pipe'] },
+  command: string,
+  args: readonly string[],
+  options: SpawnOptionsWithoutStdio & { stdio: ["pipe", "pipe", "pipe"] },
 ) => ChildProcessWithoutNullStreams;
 
 export interface CodexPrintRunRequest {
-    agent: CodexDurableAgent;
-    prompt: string;
-    executable?: string;
-    onSpawn(identity: ProcessIdentity): Promise<void>;
-    onSession(providerSessionId: string): Promise<void>;
+  agent: CodexDurableAgent;
+  prompt: string;
+  executable?: string;
+  onSpawn(identity: ProcessIdentity): Promise<void>;
+  onSession(providerSessionId: string): Promise<void>;
 }
 
 export interface CodexPrintRunResult {
-    sessionId: string;
-    result: string;
-    messages: string[];
-    exitCode: number;
+  sessionId: string;
+  result: string;
+  messages: string[];
+  exitCode: number;
 }
 
 export interface CodexPrintRunnerOptions {
-    spawn?: Spawn;
-    processInspector?: ProcessInspector;
-    maxLineBytes?: number;
+  spawn?: Spawn;
+  processInspector?: ProcessInspector;
+  maxLineBytes?: number;
 }
 
 export class CodexPrintRunner {
-    private readonly spawn: Spawn;
-    private readonly processInspector: ProcessInspector;
-    private readonly maxLineBytes: number;
+  private readonly spawn: Spawn;
+  private readonly processInspector: ProcessInspector;
+  private readonly maxLineBytes: number;
 
-    constructor(options: CodexPrintRunnerOptions = {}) {
-        this.spawn = options.spawn ?? (nodeSpawn as Spawn);
-        this.processInspector = options.processInspector ?? new LocalProcessInspector();
-        this.maxLineBytes = options.maxLineBytes ?? 1024 * 1024;
-    }
+  constructor(options: CodexPrintRunnerOptions = {}) {
+    this.spawn = options.spawn ?? (nodeSpawn as Spawn);
+    this.processInspector = options.processInspector ?? new LocalProcessInspector();
+    this.maxLineBytes = options.maxLineBytes ?? 1024 * 1024;
+  }
 
-    async run(request: CodexPrintRunRequest): Promise<CodexPrintRunResult> {
-        const args = buildCodexExecArgs(request.agent);
-        const child = this.spawn(request.executable ?? 'codex', args, {
-            cwd: request.agent.cwd, shell: false, stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const identity = this.verifyProcessIdentity(child);
+  async run(request: CodexPrintRunRequest): Promise<CodexPrintRunResult> {
+    const args = buildCodexExecArgs(request.agent);
+    const child = this.spawn(request.executable ?? "codex", args, {
+      cwd: request.agent.cwd,
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    const identity = this.verifyProcessIdentity(child);
 
-        const parser = new CodexStreamParser(request.agent.providerSessionId, request.onSession, this.maxLineBytes);
-        let processing = Promise.resolve();
+    const parser = new CodexStreamParser(
+      request.agent.providerSessionId,
+      request.onSession,
+      this.maxLineBytes,
+    );
+    let processing = Promise.resolve();
 
-        child.stdout.on('data', (chunk: Buffer | string) => {
-            if (parser.hasFailed()) return;
-            processing = processing.then(() => parser.accept(chunk)).catch((error) => parser.fail(error));
-        });
-        child.stderr.resume();
-        const closed = waitForChildClose(child);
-        try {
-            await request.onSpawn(identity);
-        } catch (error) {
-            child.kill();
-            throw error;
-        }
-        child.stdin.end(request.prompt);
-        const { code, signal } = await closed.catch(() => {
-            throw new CodexPrintError('Codex process failed to start or communicate.', 'CODEX_PROCESS');
-        });
-        await processing;
-        return parser.result({ code, signal });
+    child.stdout.on("data", (chunk: Buffer | string) => {
+      if (parser.hasFailed()) return;
+      processing = processing.then(() => parser.accept(chunk)).catch((error) => parser.fail(error));
+    });
+    child.stderr.resume();
+    const closed = waitForChildClose(child);
+    try {
+      await request.onSpawn(identity);
+    } catch (error) {
+      child.kill();
+      throw error;
     }
+    child.stdin.end(request.prompt);
+    const { code, signal } = await closed.catch(() => {
+      throw new CodexPrintError("Codex process failed to start or communicate.", "CODEX_PROCESS");
+    });
+    await processing;
+    return parser.result({ code, signal });
+  }
 
-    private verifyProcessIdentity(child: ChildProcessWithoutNullStreams): ProcessIdentity {
-        if (!child.pid) {
-            child.kill();
-            throw new CodexPrintError('Codex process did not provide a PID.', 'CODEX_PROCESS');
-        }
-        const identity = this.processInspector.getIdentity(child.pid);
-        if (!identity) {
-            child.kill();
-            throw new CodexPrintError('Cannot verify Codex process identity.', 'CODEX_PROCESS');
-        }
-        return identity;
+  private verifyProcessIdentity(child: ChildProcessWithoutNullStreams): ProcessIdentity {
+    if (!child.pid) {
+      child.kill();
+      throw new CodexPrintError("Codex process did not provide a PID.", "CODEX_PROCESS");
+    }
+    const identity = this.processInspector.getIdentity(child.pid);
+    if (!identity) {
+      child.kill();
+      throw new CodexPrintError("Cannot verify Codex process identity.", "CODEX_PROCESS");
     }
+    return identity;
+  }
 }
 
 function buildCodexExecArgs(agent: CodexDurableAgent): string[] {
-    return agent.providerSessionId === null
-        ? ['exec', '--json', '-']
-        : ['exec', 'resume', '--json', agent.providerSessionId, '-'];
+  return agent.providerSessionId === null
+    ? ["exec", "--json", "-"]
+    : ["exec", "resume", "--json", agent.providerSessionId, "-"];
 }

package/src/providers/codex/durable/CodexStreamParser.ts

@@ -1,104 +1,117 @@
-import { CodexPrintError } from '../../../durable/DurableAgent.js';
-import { isUuid, LineBuffer, type ChildCloseResult } from '../../../durable/utils.js';
-import type { CodexPrintRunResult } from './CodexPrintRunner.js';
+import { CodexPrintError } from "../../../durable/DurableAgent.js";
+import { isUuid, LineBuffer, type ChildCloseResult } from "../../../durable/utils.js";
+import type { CodexPrintRunResult } from "./CodexPrintRunner.js";
 
 export class CodexStreamParser {
-    private readonly lines: LineBuffer;
-    private sessionId: string | null = null;
-    private turnCompleted = false;
-    private readonly messages: string[] = [];
-    private protocolError: CodexPrintError | null = null;
+  private readonly lines: LineBuffer;
+  private sessionId: string | null = null;
+  private turnCompleted = false;
+  private readonly messages: string[] = [];
+  private protocolError: CodexPrintError | null = null;
 
-    constructor(
-        private readonly expectedSessionId: string | null,
-        private readonly onSession: (providerSessionId: string) => Promise<void>,
-        maxLineBytes: number,
-    ) {
-        this.lines = new LineBuffer(
-            maxLineBytes,
-            () => new CodexPrintError('Codex stream line exceeded the safety limit.', 'CODEX_PROTOCOL'),
-        );
-    }
+  constructor(
+    private readonly expectedSessionId: string | null,
+    private readonly onSession: (providerSessionId: string) => Promise<void>,
+    maxLineBytes: number,
+  ) {
+    this.lines = new LineBuffer(
+      maxLineBytes,
+      () => new CodexPrintError("Codex stream line exceeded the safety limit.", "CODEX_PROTOCOL"),
+    );
+  }
 
-    hasFailed(): boolean {
-        return this.protocolError !== null;
-    }
+  hasFailed(): boolean {
+    return this.protocolError !== null;
+  }
 
-    async accept(chunk: Buffer | string): Promise<void> {
-        for (const line of this.lines.accept(chunk)) {
-            await this.processLine(line);
-        }
+  async accept(chunk: Buffer | string): Promise<void> {
+    for (const line of this.lines.accept(chunk)) {
+      await this.processLine(line);
     }
+  }
 
-    fail(error: unknown): void {
-        this.protocolError = error instanceof CodexPrintError
-            ? error
-            : new CodexPrintError('Codex stream processing failed.', 'CODEX_PROTOCOL');
-    }
+  fail(error: unknown): void {
+    this.protocolError =
+      error instanceof CodexPrintError
+        ? error
+        : new CodexPrintError("Codex stream processing failed.", "CODEX_PROTOCOL");
+  }
 
-    result(close: ChildCloseResult): CodexPrintRunResult {
-        if (this.protocolError) throw this.protocolError;
-        this.lines.assertComplete(
-            () => new CodexPrintError('Codex stream ended with incomplete JSON.', 'CODEX_PROTOCOL'),
-        );
+  result(close: ChildCloseResult): CodexPrintRunResult {
+    if (this.protocolError) throw this.protocolError;
+    this.lines.assertComplete(
+      () => new CodexPrintError("Codex stream ended with incomplete JSON.", "CODEX_PROTOCOL"),
+    );
 
-        if (close.code !== 0) {
-            throw new CodexPrintError(`Codex print run failed${close.signal ? ` (${close.signal})` : '.'}`, 'CODEX_PROCESS');
-        }
-        if (this.sessionId === null) throw new CodexPrintError('Codex stream ended without a thread identity.', 'CODEX_PROTOCOL');
-        if (!this.turnCompleted) throw new CodexPrintError('Codex stream ended before turn completion.', 'CODEX_PROTOCOL');
-        if (this.messages.length === 0) throw new CodexPrintError('Codex stream ended without an assistant result.', 'CODEX_RESULT_MISSING');
-        return {
-            sessionId: this.sessionId,
-            result: this.messages.at(-1)!,
-            messages: this.messages,
-            exitCode: close.code,
-        };
+    if (close.code !== 0) {
+      throw new CodexPrintError(
+        `Codex print run failed${close.signal ? ` (${close.signal})` : "."}`,
+        "CODEX_PROCESS",
+      );
     }
+    if (this.sessionId === null)
+      throw new CodexPrintError("Codex stream ended without a thread identity.", "CODEX_PROTOCOL");
+    if (!this.turnCompleted)
+      throw new CodexPrintError("Codex stream ended before turn completion.", "CODEX_PROTOCOL");
+    if (this.messages.length === 0)
+      throw new CodexPrintError(
+        "Codex stream ended without an assistant result.",
+        "CODEX_RESULT_MISSING",
+      );
+    return {
+      sessionId: this.sessionId,
+      result: this.messages.at(-1)!,
+      messages: this.messages,
+      exitCode: close.code,
+    };
+  }
 
-    private async processLine(line: Buffer): Promise<void> {
-        if (this.protocolError || line.length === 0) return;
+  private async processLine(line: Buffer): Promise<void> {
+    if (this.protocolError || line.length === 0) return;
 
-        const event = this.parseEvent(line);
-        if (event.type === 'thread.started') {
-            await this.recordSession(event);
-        } else if (event.type === 'item.completed') {
-            this.recordAssistantMessage(event.item);
-        } else if (event.type === 'turn.completed') {
-            this.turnCompleted = true;
-        }
+    const event = this.parseEvent(line);
+    if (event.type === "thread.started") {
+      await this.recordSession(event);
+    } else if (event.type === "item.completed") {
+      this.recordAssistantMessage(event.item);
+    } else if (event.type === "turn.completed") {
+      this.turnCompleted = true;
     }
+  }
 
-    private parseEvent(line: Buffer): Record<string, unknown> {
-        let value: unknown;
-        try {
-            value = JSON.parse(line.toString('utf8'));
-        } catch {
-            throw new CodexPrintError('Codex emitted malformed stream JSON.', 'CODEX_PROTOCOL');
-        }
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            throw new CodexPrintError('Codex emitted a non-object stream message.', 'CODEX_PROTOCOL');
-        }
-        return value as Record<string, unknown>;
+  private parseEvent(line: Buffer): Record<string, unknown> {
+    let value: unknown;
+    try {
+      value = JSON.parse(line.toString("utf8"));
+    } catch {
+      throw new CodexPrintError("Codex emitted malformed stream JSON.", "CODEX_PROTOCOL");
     }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new CodexPrintError("Codex emitted a non-object stream message.", "CODEX_PROTOCOL");
+    }
+    return value as Record<string, unknown>;
+  }
 
-    private async recordSession(event: Record<string, unknown>): Promise<void> {
-        const sessionId = String(event.thread_id ?? '');
-        if (this.sessionId !== null || !isUuid(sessionId)) {
-            throw new CodexPrintError('Codex emitted an invalid thread identity.', 'CODEX_PROTOCOL');
-        }
-        if (this.expectedSessionId !== null && this.expectedSessionId !== sessionId) {
-            throw new CodexPrintError('Codex returned a different session identity.', 'CODEX_SESSION_MISMATCH');
-        }
-        this.sessionId = sessionId;
-        await this.onSession(sessionId);
+  private async recordSession(event: Record<string, unknown>): Promise<void> {
+    const sessionId = String(event.thread_id ?? "");
+    if (this.sessionId !== null || !isUuid(sessionId)) {
+      throw new CodexPrintError("Codex emitted an invalid thread identity.", "CODEX_PROTOCOL");
+    }
+    if (this.expectedSessionId !== null && this.expectedSessionId !== sessionId) {
+      throw new CodexPrintError(
+        "Codex returned a different session identity.",
+        "CODEX_SESSION_MISMATCH",
+      );
     }
+    this.sessionId = sessionId;
+    await this.onSession(sessionId);
+  }
 
-    private recordAssistantMessage(item: unknown): void {
-        if (!item || typeof item !== 'object' || Array.isArray(item)) return;
-        const record = item as Record<string, unknown>;
-        if (record.type === 'agent_message' && typeof record.text === 'string' && record.text.trim()) {
-            this.messages.push(record.text);
-        }
+  private recordAssistantMessage(item: unknown): void {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return;
+    const record = item as Record<string, unknown>;
+    if (record.type === "agent_message" && typeof record.text === "string" && record.text.trim()) {
+      this.messages.push(record.text);
     }
+  }
 }

package/src/providers/copilot/CopilotAdapter.ts

@@ -0,0 +1,145 @@
+/**
+ * Copilot Adapter
+ *
+ * Detects running GitHub Copilot CLI agents by:
+ * 1. Filtering Copilot processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
+ * 3. Mapping active ~/.copilot/session-state/{sessionId}/inuse.{pid}.lock files to processes
+ * 4. Reading events.jsonl as the primary session/conversation source
+ * 5. Reading workspace.yaml as a flat fallback metadata source
+ */
+
+import * as path from "path";
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ConversationMessage,
+  ListSessionsOptions,
+  ProcessInfo,
+  SessionSummary,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import {
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+  findWrapperProcess,
+  findWrapperProcessPids,
+} from "../../utils/process.js";
+import { AgentRegistry, type RegistryEntry } from "../../utils/AgentRegistry.js";
+import { CopilotAgentMapper } from "./CopilotAgentMapper.js";
+import { CopilotSessionLocator } from "./CopilotSessionLocator.js";
+import { CopilotSessionParser } from "./CopilotSessionParser.js";
+
+export interface CopilotAdapterOptions {
+  sessionStateDir?: string;
+}
+
+export class CopilotAdapter implements AgentAdapter {
+  readonly type = "copilot" as const;
+  readonly processNames = ["copilot"] as const;
+
+  private readonly registry: AgentRegistry;
+  private readonly parser: CopilotSessionParser;
+  private readonly mapper: CopilotAgentMapper;
+  private readonly locator: CopilotSessionLocator;
+
+  constructor(
+    registry: AgentRegistry = AgentRegistry.default(),
+    options: CopilotAdapterOptions = {},
+  ) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.registry = registry;
+    this.parser = new CopilotSessionParser();
+    this.mapper = new CopilotAgentMapper(this.parser);
+    this.locator = new CopilotSessionLocator({
+      sessionStateDir: options.sessionStateDir ?? path.join(homeDir, ".copilot", "session-state"),
+    });
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return this.isCopilotExecutable(processInfo.command);
+  }
+
+  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 processByPid = new Map(processes.map((proc) => [proc.pid, proc]));
+    const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
+    const matchedPids = new Set<number>();
+    const matchedProcesses: ProcessInfo[] = [];
+    const agents: AgentInfo[] = [];
+
+    for (const lock of this.locator.discoverActiveLocks()) {
+      const proc = processByPid.get(lock.pid);
+      if (!proc) continue;
+
+      const session = this.parser.readSessionDir(lock.sessionDir, lock.sessionId);
+      if (!session) continue;
+
+      const agent = this.mapper.mapSessionToAgent(session, proc);
+      this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+      agents.push(agent);
+      matchedPids.add(proc.pid);
+      matchedProcesses.push(proc);
+    }
+
+    const wrapperPids = findWrapperProcessPids(processes, matchedProcesses);
+    for (const proc of processes) {
+      if (!matchedPids.has(proc.pid) && !wrapperPids.has(proc.pid)) {
+        const agent = this.mapper.mapProcessOnlyAgent(proc);
+        this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+        agents.push(agent);
+      }
+    }
+
+    return agents;
+  }
+
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    return this.parser.getConversation(sessionFilePath, options);
+  }
+
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    const summaries: SessionSummary[] = [];
+
+    for (const { sessionDir, sessionId } of this.locator.listSessionDirs()) {
+      const session = this.parser.readSessionDir(sessionDir, sessionId);
+      if (!session) continue;
+      if (opts?.cwd !== undefined && session.projectPath !== opts.cwd) continue;
+
+      summaries.push({
+        type: this.type,
+        sessionId: session.sessionId,
+        cwd: session.projectPath,
+        firstUserMessage: session.firstUserMessage,
+        lastActive: session.lastActive,
+        startedAt: session.sessionStart,
+        sessionFilePath: session.eventsFilePath,
+      });
+    }
+
+    return summaries;
+  }
+
+  private applyWrapperRegistryName(
+    agent: AgentInfo,
+    processInfo: ProcessInfo,
+    processes: ProcessInfo[],
+    registryEntriesByPid: Map<number, RegistryEntry>,
+  ): void {
+    const wrapper = findWrapperProcess(processes, processInfo);
+    const wrapperEntry = wrapper ? registryEntriesByPid.get(wrapper.pid) : undefined;
+    if (wrapperEntry?.type === this.type) {
+      agent.name = wrapperEntry.name;
+    }
+  }
+
+  private isCopilotExecutable(command: string): boolean {
+    const base = executableBasename(command);
+    return base === "copilot" || base === "copilot.exe";
+  }
+}

package/src/providers/copilot/CopilotAgentMapper.ts

@@ -0,0 +1,36 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import { CopilotSessionParser, type CopilotSession } from "./CopilotSessionParser.js";
+
+export class CopilotAgentMapper {
+  constructor(private readonly parser: CopilotSessionParser = new CopilotSessionParser()) {}
+
+  mapSessionToAgent(session: CopilotSession, processInfo: ProcessInfo): AgentInfo {
+    const projectPath = session.projectPath || processInfo.cwd || "";
+    return {
+      name: generateAgentName(projectPath, processInfo.pid),
+      type: "copilot",
+      status: this.parser.determineStatus(session),
+      summary: session.summary || "Copilot session active",
+      pid: processInfo.pid,
+      projectPath,
+      sessionId: session.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: session.eventsFilePath,
+    };
+  }
+
+  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
+    return {
+      name: generateAgentName(processInfo.cwd || "", processInfo.pid),
+      type: "copilot",
+      status: AgentStatus.RUNNING,
+      summary: "Copilot process running",
+      pid: processInfo.pid,
+      projectPath: processInfo.cwd || "",
+      sessionId: `pid-${processInfo.pid}`,
+      lastActive: new Date(),
+    };
+  }
+}

package/src/providers/copilot/CopilotSessionLocator.ts

@@ -0,0 +1,57 @@
+import * as path from "path";
+import { isDirectory, safeReaddir } from "../../utils/session.js";
+
+export interface CopilotLock {
+  sessionDir: string;
+  sessionId: string;
+  pid: number;
+}
+
+export interface CopilotSessionDir {
+  sessionDir: string;
+  sessionId: string;
+}
+
+export interface CopilotSessionLocatorOptions {
+  sessionStateDir?: string;
+}
+
+export class CopilotSessionLocator {
+  private readonly sessionStateDir: string;
+
+  constructor(options: CopilotSessionLocatorOptions = {}) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.sessionStateDir =
+      options.sessionStateDir ?? path.join(homeDir, ".copilot", "session-state");
+  }
+
+  listSessionDirs(): CopilotSessionDir[] {
+    if (!isDirectory(this.sessionStateDir)) return [];
+
+    const sessionDirs: CopilotSessionDir[] = [];
+    for (const sessionId of safeReaddir(this.sessionStateDir)) {
+      const sessionDir = path.join(this.sessionStateDir, sessionId);
+      if (!isDirectory(sessionDir)) continue;
+
+      sessionDirs.push({ sessionDir, sessionId });
+    }
+
+    return sessionDirs;
+  }
+
+  discoverActiveLocks(): CopilotLock[] {
+    const locks: CopilotLock[] = [];
+    for (const { sessionDir, sessionId } of this.listSessionDirs()) {
+      for (const entry of safeReaddir(sessionDir)) {
+        const match = entry.match(/^inuse\.(\d+)\.lock$/);
+        if (!match) continue;
+
+        const pid = Number.parseInt(match[1], 10);
+        if (!Number.isFinite(pid)) continue;
+        locks.push({ sessionDir, sessionId, pid });
+      }
+    }
+
+    return locks;
+  }
+}