@orgloop/agentctl 1.2.0 → 1.3.0

package/dist/adapters/claude-code.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -38,6 +38,8 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: ClaudeCodeAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/claude-code.js

@@ -5,7 +5,9 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import { buildSpawnEnv } from "../utils/daemon-env.js";
 import { readHead, readTail } from "../utils/partial-read.js";
+import { resolveBinaryPath } from "../utils/resolve-binary.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_CLAUDE_DIR = path.join(os.homedir(), ".claude");
 // Default: only show stopped sessions from the last 7 days
@@ -30,6 +32,57 @@ export class ClaudeCodeAdapter {
         this.getPids = opts?.getPids || getClaudePids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const results = [];
+        let projectDirs;
+        try {
+            projectDirs = await fs.readdir(this.projectsDir);
+        }
+        catch {
+            return [];
+        }
+        for (const projDir of projectDirs) {
+            const projPath = path.join(this.projectsDir, projDir);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const entries = await this.getEntriesForProject(projPath, projDir);
+            for (const { entry, index } of entries) {
+                if (entry.isSidechain)
+                    continue;
+                const isRunning = await this.isSessionRunning(entry, index, runningPids);
+                const { model, tokens } = await this.parseSessionTail(entry.fullPath);
+                results.push({
+                    id: entry.sessionId,
+                    status: isRunning ? "running" : "stopped",
+                    adapter: this.id,
+                    cwd: index.originalPath || entry.projectPath,
+                    model,
+                    startedAt: new Date(entry.created),
+                    stoppedAt: isRunning ? undefined : new Date(entry.modified),
+                    pid: isRunning
+                        ? await this.findMatchingPid(entry, index, runningPids)
+                        : undefined,
+                    prompt: entry.firstPrompt?.slice(0, 200),
+                    tokens,
+                    nativeMetadata: {
+                        projectDir: index.originalPath || entry.projectPath,
+                        gitBranch: entry.gitBranch,
+                        messageCount: entry.messageCount,
+                    },
+                });
+            }
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const entry = await this.findIndexEntry(sessionId);
+        if (!entry)
+            return false;
+        return this.isSessionRunning(entry.entry, entry.index, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessions = [];
@@ -123,7 +176,7 @@ export class ClaudeCodeAdapter {
             args.push("--model", opts.model);
         }
         args.push("-p", opts.prompt);
-        const env = { ...process.env, ...opts.env };
+        const env = buildSpawnEnv(undefined, opts.env);
         const cwd = opts.cwd || process.cwd();
         // Write stdout to a log file so we can extract the session ID
         // without keeping a pipe open (which would prevent full detachment).
@@ -131,12 +184,17 @@ export class ClaudeCodeAdapter {
         const logPath = path.join(this.sessionsMetaDir, `launch-${Date.now()}.log`);
         const logFd = await fs.open(logPath, "w");
         // Capture stderr to the same log file for debugging launch failures
-        const child = spawn("claude", args, {
+        const claudePath = await resolveBinaryPath("claude");
+        const child = spawn(claudePath, args, {
             cwd,
             env,
             stdio: ["ignore", logFd.fd, logFd.fd],
             detached: true,
         });
+        // Handle spawn errors (e.g. ENOENT) gracefully instead of crashing the daemon
+        child.on("error", (err) => {
+            console.error(`[claude-code] spawn error: ${err.message}`);
+        });
         // Fully detach: child runs in its own process group.
         // When the wrapper gets SIGTERM, the child keeps running.
         child.unref();
@@ -250,11 +308,15 @@ export class ClaudeCodeAdapter {
         ];
         const session = await this.status(sessionId).catch(() => null);
         const cwd = session?.cwd || process.cwd();
-        const child = spawn("claude", args, {
+        const claudePath = await resolveBinaryPath("claude");
+        const child = spawn(claudePath, args, {
             cwd,
             stdio: ["pipe", "pipe", "pipe"],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[claude-code] resume spawn error: ${err.message}`);
+        });
         child.unref();
     }
     async *events() {

package/dist/adapters/codex.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface CodexPidInfo {
     pid: number;
     cwd: string;
@@ -34,6 +34,8 @@ export declare class CodexAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: CodexAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/codex.js

@@ -5,6 +5,8 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import { buildSpawnEnv } from "../utils/daemon-env.js";
+import { resolveBinaryPath } from "../utils/resolve-binary.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_CODEX_DIR = path.join(os.homedir(), ".codex");
 // Default: only show stopped sessions from the last 7 days
@@ -28,6 +30,41 @@ export class CodexAdapter {
         this.getPids = opts?.getPids || getCodexPids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const sessionInfos = await this.discoverSessions();
+        const results = [];
+        for (const info of sessionInfos) {
+            const isRunning = this.isSessionRunning(info, runningPids);
+            const pid = isRunning
+                ? this.findMatchingPid(info, runningPids)
+                : undefined;
+            results.push({
+                id: info.id,
+                status: isRunning ? "running" : "stopped",
+                adapter: this.id,
+                cwd: info.cwd,
+                model: info.model,
+                startedAt: info.created,
+                stoppedAt: isRunning ? undefined : info.modified,
+                pid,
+                prompt: info.firstPrompt,
+                tokens: info.tokens,
+                nativeMetadata: {
+                    cliVersion: info.cliVersion,
+                    lastMessage: info.lastMessage,
+                },
+            });
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const info = await this.findSession(sessionId);
+        if (!info)
+            return false;
+        return this.isSessionRunning(info, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessionInfos = await this.discoverSessions();
@@ -102,16 +139,20 @@ export class CodexAdapter {
         const cwd = opts.cwd || process.cwd();
         args.push("--cd", cwd);
         args.push(opts.prompt);
-        const env = { ...process.env, ...opts.env };
+        const env = buildSpawnEnv(undefined, opts.env);
         await fs.mkdir(this.sessionsMetaDir, { recursive: true });
         const logPath = path.join(this.sessionsMetaDir, `launch-${Date.now()}.log`);
         const logFd = await fs.open(logPath, "w");
-        const child = spawn("codex", args, {
+        const codexPath = await resolveBinaryPath("codex");
+        const child = spawn(codexPath, args, {
             cwd,
             env,
             stdio: ["ignore", logFd.fd, "ignore"],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[codex] spawn error: ${err.message}`);
+        });
         child.unref();
         const pid = child.pid;
         const now = new Date();
@@ -219,11 +260,15 @@ export class CodexAdapter {
             sessionId,
             message,
         ];
-        const child = spawn("codex", args, {
+        const codexPath = await resolveBinaryPath("codex");
+        const child = spawn(codexPath, args, {
             cwd,
             stdio: ["pipe", "pipe", "pipe"],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[codex] resume spawn error: ${err.message}`);
+        });
         child.unref();
     }
     async *events() {

package/dist/adapters/openclaw.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface DeviceIdentity {
     deviceId: string;
     publicKeyPem: string;
@@ -122,6 +122,8 @@ export declare class OpenClawAdapter implements AgentAdapter {
     private readonly rpcCall;
     constructor(opts?: OpenClawAdapterOpts);
     private tryLoadDeviceIdentity;
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/openclaw.js

@@ -197,6 +197,62 @@ export class OpenClawAdapter {
             return null;
         }
     }
+    async discover() {
+        if (!this.authToken)
+            return [];
+        let result;
+        try {
+            result = (await this.rpcCall("sessions.list", {
+                includeDerivedTitles: true,
+                includeLastMessage: true,
+            }));
+        }
+        catch {
+            return [];
+        }
+        return result.sessions.map((row) => {
+            const updatedAt = row.updatedAt ?? 0;
+            const model = row.model || result.defaults.model || undefined;
+            const input = row.inputTokens ?? 0;
+            const output = row.outputTokens ?? 0;
+            // Gateway is the source of truth: if a session is in the list, it's alive.
+            // Don't guess from timestamps — sessions can be idle for hours between messages.
+            return {
+                id: row.sessionId || row.key,
+                status: "running",
+                adapter: this.id,
+                model,
+                startedAt: updatedAt > 0 ? new Date(updatedAt) : new Date(),
+                prompt: row.derivedTitle || row.displayName || row.label,
+                tokens: input || output ? { in: input, out: output } : undefined,
+                nativeMetadata: {
+                    key: row.key,
+                    kind: row.kind,
+                    channel: row.channel,
+                    displayName: row.displayName,
+                    modelProvider: row.modelProvider || result.defaults.modelProvider,
+                    lastMessagePreview: row.lastMessagePreview,
+                },
+            };
+        });
+    }
+    async isAlive(sessionId) {
+        if (!this.authToken)
+            return false;
+        try {
+            const result = (await this.rpcCall("sessions.list", {
+                search: sessionId,
+            }));
+            // Gateway is the source of truth: if a session is in the list, it's alive.
+            return result.sessions.some((s) => s.sessionId === sessionId ||
+                s.key === sessionId ||
+                s.sessionId?.startsWith(sessionId) ||
+                s.key.startsWith(sessionId));
+        }
+        catch {
+            return false;
+        }
+    }
     async list(opts) {
         if (!this.authToken) {
             console.warn("Warning: OPENCLAW_GATEWAY_TOKEN is not set — OpenClaw adapter cannot authenticate. " +
@@ -342,17 +398,18 @@ export class OpenClawAdapter {
     }
     // --- Private helpers ---
     mapRowToSession(row, defaults) {
-        const now = Date.now();
         const updatedAt = row.updatedAt ?? 0;
-        const ageMs = now - updatedAt;
-        const isActive = updatedAt > 0 && ageMs < 5 * 60 * 1000;
+        const ageMs = Date.now() - updatedAt;
+        // Gateway is the source of truth: if a session is in the list, it's alive.
+        // Use "running" for recently active sessions, "idle" for quiet ones.
+        const status = updatedAt > 0 && ageMs < 5 * 60 * 1000 ? "running" : "idle";
         const model = row.model || defaults.model || undefined;
         const input = row.inputTokens ?? 0;
         const output = row.outputTokens ?? 0;
         return {
             id: row.sessionId || row.key,
             adapter: this.id,
-            status: isActive ? "running" : "idle",
+            status,
             startedAt: updatedAt > 0 ? new Date(updatedAt) : new Date(),
             cwd: undefined,
             model,

package/dist/adapters/opencode.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -95,6 +95,8 @@ export declare class OpenCodeAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: OpenCodeAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/opencode.js

@@ -5,6 +5,8 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import { buildSpawnEnv } from "../utils/daemon-env.js";
+import { resolveBinaryPath } from "../utils/resolve-binary.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_STORAGE_DIR = path.join(os.homedir(), ".local", "share", "opencode", "storage");
 // Default: only show stopped sessions from the last 7 days
@@ -37,6 +39,63 @@ export class OpenCodeAdapter {
         this.getPids = opts?.getPids || getOpenCodePids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const results = [];
+        let projectDirs;
+        try {
+            projectDirs = await fs.readdir(this.sessionDir);
+        }
+        catch {
+            return [];
+        }
+        for (const projHash of projectDirs) {
+            const projPath = path.join(this.sessionDir, projHash);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const sessionFiles = await this.getSessionFilesForProject(projPath);
+            for (const sessionData of sessionFiles) {
+                const isRunning = await this.isSessionRunning(sessionData, runningPids);
+                const { model, tokens, cost } = await this.aggregateMessageStats(sessionData.id);
+                const createdAt = sessionData.time?.created
+                    ? new Date(sessionData.time.created)
+                    : new Date();
+                const updatedAt = sessionData.time?.updated
+                    ? new Date(sessionData.time.updated)
+                    : undefined;
+                results.push({
+                    id: sessionData.id,
+                    status: isRunning ? "running" : "stopped",
+                    adapter: this.id,
+                    cwd: sessionData.directory,
+                    model,
+                    startedAt: createdAt,
+                    stoppedAt: isRunning ? undefined : updatedAt,
+                    pid: isRunning
+                        ? await this.findMatchingPid(sessionData, runningPids)
+                        : undefined,
+                    prompt: sessionData.title?.slice(0, 200),
+                    tokens,
+                    cost,
+                    nativeMetadata: {
+                        projectID: sessionData.projectID,
+                        slug: sessionData.slug,
+                        summary: sessionData.summary,
+                        version: sessionData.version,
+                    },
+                });
+            }
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const resolved = await this.resolveSessionId(sessionId);
+        if (!resolved)
+            return false;
+        return this.isSessionRunning(resolved, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessions = [];
@@ -116,15 +175,19 @@ export class OpenCodeAdapter {
     }
     async launch(opts) {
         const args = ["run", opts.prompt];
-        const env = { ...process.env, ...opts.env };
+        const env = buildSpawnEnv(undefined, opts.env);
         const cwd = opts.cwd || process.cwd();
         await fs.mkdir(this.sessionsMetaDir, { recursive: true });
-        const child = spawn("opencode", args, {
+        const opencodePath = await resolveBinaryPath("opencode");
+        const child = spawn(opencodePath, args, {
             cwd,
             env,
             stdio: ["ignore", "pipe", "pipe"],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[opencode] spawn error: ${err.message}`);
+        });
         child.unref();
         const pid = child.pid;
         const now = new Date();
@@ -183,11 +246,15 @@ export class OpenCodeAdapter {
         if (!resolved)
             throw new Error(`Session not found for resume: ${sessionId}`);
         const cwd = resolved.directory || process.cwd();
-        const child = spawn("opencode", ["run", message], {
+        const opencodePath = await resolveBinaryPath("opencode");
+        const child = spawn(opencodePath, ["run", message], {
             cwd,
             stdio: ["ignore", "pipe", "pipe"],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[opencode] resume spawn error: ${err.message}`);
+        });
         child.unref();
     }
     async *events() {

package/dist/adapters/pi-rust.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -41,6 +41,8 @@ export declare class PiRustAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: PiRustAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/pi-rust.js

@@ -5,6 +5,8 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import { buildSpawnEnv } from "../utils/daemon-env.js";
+import { resolveBinaryPath } from "../utils/resolve-binary.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_SESSION_DIR = path.join(os.homedir(), ".pi", "agent", "sessions");
 // Default: only show stopped sessions from the last 7 days
@@ -31,6 +33,80 @@ export class PiRustAdapter {
         this.getPids = opts?.getPids || getPiRustPids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const results = [];
+        let projectDirs;
+        try {
+            const entries = await fs.readdir(this.sessionDir);
+            projectDirs = entries.filter((e) => e.startsWith("--"));
+        }
+        catch {
+            return [];
+        }
+        for (const projDir of projectDirs) {
+            const projPath = path.join(this.sessionDir, projDir);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const projectCwd = decodeProjDir(projDir);
+            const sessionFiles = await this.getSessionFiles(projPath);
+            for (const file of sessionFiles) {
+                const filePath = path.join(projPath, file);
+                const header = await this.readSessionHeader(filePath);
+                if (!header)
+                    continue;
+                const isRunning = await this.isSessionRunning(header, projectCwd, runningPids);
+                const { model, tokens, cost } = await this.parseSessionTail(filePath);
+                const firstPrompt = await this.readFirstPrompt(filePath);
+                let fileStat;
+                try {
+                    fileStat = await fs.stat(filePath);
+                }
+                catch {
+                    // ignore
+                }
+                results.push({
+                    id: header.id,
+                    status: isRunning ? "running" : "stopped",
+                    adapter: this.id,
+                    cwd: header.cwd || projectCwd,
+                    model: model || header.modelId,
+                    startedAt: new Date(header.timestamp),
+                    stoppedAt: isRunning
+                        ? undefined
+                        : fileStat
+                            ? new Date(Number(fileStat.mtimeMs))
+                            : undefined,
+                    pid: isRunning
+                        ? await this.findMatchingPid(header, projectCwd, runningPids)
+                        : undefined,
+                    prompt: firstPrompt?.slice(0, 200),
+                    tokens,
+                    cost: cost ?? undefined,
+                    nativeMetadata: {
+                        provider: header.provider,
+                        thinkingLevel: header.thinkingLevel,
+                        projectDir: projectCwd,
+                        sessionFile: filePath,
+                    },
+                });
+            }
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const filePath = await this.findSessionFile(sessionId);
+        if (!filePath)
+            return false;
+        const header = await this.readSessionHeader(filePath);
+        if (!header)
+            return false;
+        const projDir = path.basename(path.dirname(filePath));
+        const projectCwd = decodeProjDir(projDir);
+        return this.isSessionRunning(header, projectCwd, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessions = [];
@@ -129,18 +205,22 @@ export class PiRustAdapter {
         if (opts.model) {
             args.unshift("--model", opts.model);
         }
-        const env = { ...process.env, ...opts.env };
+        const env = buildSpawnEnv(undefined, opts.env);
         const cwd = opts.cwd || process.cwd();
         // Write stdout to a log file so we can extract the session ID
         await fs.mkdir(this.sessionsMetaDir, { recursive: true });
         const logPath = path.join(this.sessionsMetaDir, `launch-${Date.now()}.log`);
         const logFd = await fs.open(logPath, "w");
-        const child = spawn("pi-rust", args, {
+        const piRustPath = await resolveBinaryPath("pi-rust");
+        const child = spawn(piRustPath, args, {
             cwd,
             env,
             stdio: ["ignore", logFd.fd, "ignore"],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[pi-rust] spawn error: ${err.message}`);
+        });
         child.unref();
         const pid = child.pid;
         const now = new Date();
@@ -251,11 +331,15 @@ export class PiRustAdapter {
         else {
             args.unshift("--continue");
         }
-        const child = spawn("pi-rust", args, {
+        const piRustPath = await resolveBinaryPath("pi-rust");
+        const child = spawn(piRustPath, args, {
             cwd,
             stdio: ["pipe", "pipe", "pipe"],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[pi-rust] resume spawn error: ${err.message}`);
+        });
         child.unref();
     }
     async *events() {

package/dist/adapters/pi.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -41,6 +41,8 @@ export declare class PiAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: PiAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     /** Extract assistant messages from a JSONL session file */