@orgloop/agentctl 1.2.0 → 1.2.1

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
@@ -123,7 +125,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 +133,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 +257,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.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
@@ -102,16 +104,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 +225,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/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
@@ -116,15 +118,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 +189,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.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
@@ -129,18 +131,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 +257,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.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_PI_DIR = path.join(os.homedir(), ".pi");
 // Default: only show stopped sessions from the last 7 days
@@ -163,18 +165,22 @@ export class PiAdapter {
         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", args, {
+        const piPath = await resolveBinaryPath("pi");
+        const child = spawn(piPath, args, {
             cwd,
             env,
             stdio: ["ignore", logFd.fd, logFd.fd],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[pi] spawn error: ${err.message}`);
+        });
         // Fully detach: child runs in its own process group.
         child.unref();
         const pid = child.pid;
@@ -331,11 +337,15 @@ export class PiAdapter {
         // Launch a new pi session in the same cwd with the continuation message.
         const disc = await this.findSession(sessionId);
         const cwd = disc?.header.cwd || process.cwd();
-        const child = spawn("pi", ["-p", message], {
+        const piPath = await resolveBinaryPath("pi");
+        const child = spawn(piPath, ["-p", message], {
             cwd,
             stdio: ["pipe", "pipe", "pipe"],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[pi] resume spawn error: ${err.message}`);
+        });
         child.unref();
     }
     async *events() {

package/dist/cli.js

@@ -84,6 +84,7 @@ function formatSession(s, showGroup) {
     const row = {
         ID: s.id.slice(0, 8),
         Status: s.status,
+        Adapter: s.adapter || "-",
         Model: s.model || "-",
     };
     if (showGroup)
@@ -98,6 +99,7 @@ function formatRecord(s, showGroup) {
     const row = {
         ID: s.id.slice(0, 8),
         Status: s.status,
+        Adapter: s.adapter || "-",
         Model: s.model || "-",
     };
     if (showGroup)
@@ -868,6 +870,25 @@ program
         process.exit(1);
     }
 });
+// --- Prune command (#40) ---
+program
+    .command("prune")
+    .description("Remove dead and stale sessions from daemon state")
+    .action(async () => {
+    const daemonRunning = await ensureDaemon();
+    if (!daemonRunning) {
+        console.error("Daemon not running. Start with: agentctl daemon start");
+        process.exit(1);
+    }
+    try {
+        const result = await client.call("session.prune");
+        console.log(`Pruned ${result.pruned} dead/stale sessions`);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 // --- Daemon subcommand ---
 const daemonCmd = new Command("daemon").description("Manage the agentctl daemon");
 daemonCmd
@@ -945,8 +966,9 @@ daemonCmd
 });
 daemonCmd
     .command("status")
-    .description("Show daemon status")
+    .description("Show daemon status and all daemon-related processes")
     .action(async () => {
+    // Show daemon status
     try {
         const status = await client.call("daemon.status");
         console.log(`Daemon running (PID ${status.pid})`);
@@ -958,6 +980,38 @@ daemonCmd
     catch {
         console.log("Daemon not running");
     }
+    // Show all daemon-related processes (#39)
+    const configDir = path.join(os.homedir(), ".agentctl");
+    const { getSupervisorPid } = await import("./daemon/supervisor.js");
+    const supPid = await getSupervisorPid();
+    let daemonPid = null;
+    try {
+        const raw = await fs.readFile(path.join(configDir, "agentctl.pid"), "utf-8");
+        const pid = Number.parseInt(raw.trim(), 10);
+        try {
+            process.kill(pid, 0);
+            daemonPid = pid;
+        }
+        catch {
+            // PID file is stale
+        }
+    }
+    catch {
+        // No PID file
+    }
+    console.log("\nDaemon-related processes:");
+    if (supPid) {
+        console.log(`  Supervisor: PID ${supPid} (alive)`);
+    }
+    else {
+        console.log("  Supervisor: not running");
+    }
+    if (daemonPid) {
+        console.log(`  Daemon: PID ${daemonPid} (alive)`);
+    }
+    else {
+        console.log("  Daemon: not running");
+    }
 });
 daemonCmd
     .command("restart")

package/dist/daemon/server.js

@@ -1,9 +1,11 @@
+import { execFile } from "node:child_process";
 import { EventEmitter } from "node:events";
 import fs from "node:fs/promises";
 import http from "node:http";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
+import { promisify } from "node:util";
 import { ClaudeCodeAdapter } from "../adapters/claude-code.js";
 import { CodexAdapter } from "../adapters/codex.js";
 import { OpenClawAdapter } from "../adapters/openclaw.js";
@@ -11,29 +13,38 @@ import { OpenCodeAdapter } from "../adapters/opencode.js";
 import { PiAdapter } from "../adapters/pi.js";
 import { PiRustAdapter } from "../adapters/pi-rust.js";
 import { migrateLocks } from "../migration/migrate-locks.js";
+import { saveEnvironment } from "../utils/daemon-env.js";
+import { clearBinaryCache } from "../utils/resolve-binary.js";
 import { FuseEngine } from "./fuse-engine.js";
 import { LockManager } from "./lock-manager.js";
 import { MetricsRegistry } from "./metrics.js";
 import { SessionTracker } from "./session-tracker.js";
 import { StateManager } from "./state.js";
+const execFileAsync = promisify(execFile);
 const startTime = Date.now();
 export async function startDaemon(opts = {}) {
     const configDir = opts.configDir || path.join(os.homedir(), ".agentctl");
     await fs.mkdir(configDir, { recursive: true });
-    // 1. Check for existing daemon
     const pidFilePath = path.join(configDir, "agentctl.pid");
-    const existingPid = await readPidFile(pidFilePath);
-    if (existingPid && isProcessAlive(existingPid)) {
-        throw new Error(`Daemon already running (PID ${existingPid})`);
-    }
-    // 2. Clean stale socket
     const sockPath = path.join(configDir, "agentctl.sock");
+    // 1. Kill stale daemon/supervisor processes before anything else (#39)
+    await killStaleDaemons(configDir);
+    // 2. Verify no daemon is actually running by trying to connect to socket
+    const socketAlive = await isSocketAlive(sockPath);
+    if (socketAlive) {
+        throw new Error("Daemon already running (socket responsive)");
+    }
+    // 3. Clean stale socket file
     await fs.rm(sockPath, { force: true });
-    // 3. Run migration (idempotent)
+    // 4. Save shell environment for subprocess spawning (#42)
+    await saveEnvironment(configDir);
+    // 5. Clear binary cache on restart (#41 — pick up moved/updated binaries)
+    clearBinaryCache();
+    // 6. Run migration (idempotent)
     await migrateLocks(configDir).catch((err) => console.error("Migration warning:", err.message));
-    // 4. Load persisted state
+    // 7. Load persisted state
     const state = await StateManager.load(configDir);
-    // 5. Initialize subsystems
+    // 8. Initialize subsystems
     const adapters = opts.adapters || {
         "claude-code": new ClaudeCodeAdapter(),
         codex: new CodexAdapter(),
@@ -54,11 +65,13 @@ export async function startDaemon(opts = {}) {
     emitter.on("fuse.fired", () => {
         metrics.recordFuseFired();
     });
-    // 6. Resume fuse timers
+    // 9. Validate all sessions on startup — mark dead ones as stopped (#40)
+    sessionTracker.validateAllSessions();
+    // 10. Resume fuse timers
     fuseEngine.resumeTimers();
-    // 7. Start session polling
+    // 11. Start session polling
     sessionTracker.startPolling();
-    // 8. Create request handler
+    // 12. Create request handler
     const handleRequest = createRequestHandler({
         sessionTracker,
         lockManager,
@@ -69,7 +82,7 @@ export async function startDaemon(opts = {}) {
         configDir,
         sockPath,
     });
-    // 9. Start Unix socket server
+    // 13. Start Unix socket server
     const socketServer = net.createServer((conn) => {
         let buffer = "";
         conn.on("data", (chunk) => {
@@ -105,7 +118,9 @@ export async function startDaemon(opts = {}) {
         socketServer.listen(sockPath, () => resolve());
         socketServer.on("error", reject);
     });
-    // 10. Start HTTP metrics server
+    // 14. Write PID file (after socket is listening — acts as "lock acquired")
+    await fs.writeFile(pidFilePath, String(process.pid));
+    // 15. Start HTTP metrics server
     const metricsPort = opts.metricsPort ?? 9200;
     const httpServer = http.createServer((req, res) => {
         if (req.url === "/metrics" && req.method === "GET") {
@@ -123,8 +138,6 @@ export async function startDaemon(opts = {}) {
         httpServer.listen(metricsPort, "127.0.0.1", () => resolve());
         httpServer.on("error", reject);
     });
-    // 11. Write PID file
-    await fs.writeFile(pidFilePath, String(process.pid));
     // Shutdown function
     const shutdown = async () => {
         sessionTracker.stopPolling();
@@ -136,7 +149,7 @@ export async function startDaemon(opts = {}) {
         await fs.rm(sockPath, { force: true });
         await fs.rm(pidFilePath, { force: true });
     };
-    // 12. Signal handlers
+    // 16. Signal handlers
     for (const sig of ["SIGTERM", "SIGINT"]) {
         process.on(sig, async () => {
             console.log(`Received ${sig}, shutting down...`);
@@ -149,6 +162,86 @@ export async function startDaemon(opts = {}) {
     console.log(`  Metrics: http://localhost:${metricsPort}/metrics`);
     return { socketServer, httpServer, shutdown };
 }
+// --- Stale daemon cleanup (#39) ---
+/**
+ * Find and kill ALL stale agentctl daemon/supervisor processes.
+ * This ensures singleton enforcement even after unclean shutdowns.
+ */
+async function killStaleDaemons(configDir) {
+    // 1. Kill processes recorded in PID files
+    for (const pidFile of ["agentctl.pid", "supervisor.pid"]) {
+        const p = path.join(configDir, pidFile);
+        const pid = await readPidFile(p);
+        if (pid && pid !== process.pid && isProcessAlive(pid)) {
+            try {
+                process.kill(pid, "SIGTERM");
+                // Wait briefly for clean shutdown
+                await sleep(500);
+                if (isProcessAlive(pid)) {
+                    process.kill(pid, "SIGKILL");
+                }
+            }
+            catch {
+                // Already gone
+            }
+        }
+        // Clean up stale PID file
+        await fs.rm(p, { force: true }).catch(() => { });
+    }
+    // 2. Scan ps for any remaining agentctl daemon processes
+    try {
+        const { stdout } = await execFileAsync("ps", ["aux"]);
+        for (const line of stdout.split("\n")) {
+            if (!line.includes("agentctl") || !line.includes("daemon"))
+                continue;
+            if (line.includes("grep"))
+                continue;
+            const fields = line.trim().split(/\s+/);
+            if (fields.length < 2)
+                continue;
+            const pid = Number.parseInt(fields[1], 10);
+            if (Number.isNaN(pid) || pid === process.pid)
+                continue;
+            // Also skip our parent process (supervisor)
+            if (pid === process.ppid)
+                continue;
+            try {
+                process.kill(pid, "SIGTERM");
+                await sleep(200);
+                if (isProcessAlive(pid)) {
+                    process.kill(pid, "SIGKILL");
+                }
+            }
+            catch {
+                // Already gone
+            }
+        }
+    }
+    catch {
+        // ps failed — best effort
+    }
+}
+/**
+ * Check if a Unix socket is actually responsive (not just a stale file).
+ */
+async function isSocketAlive(sockPath) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection(sockPath);
+        const timeout = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, 1000);
+        socket.on("connect", () => {
+            clearTimeout(timeout);
+            socket.destroy();
+            resolve(true);
+        });
+        socket.on("error", () => {
+            clearTimeout(timeout);
+            resolve(false);
+        });
+    });
+}
 function createRequestHandler(ctx) {
     return async (req) => {
         const params = (req.params || {});
@@ -260,6 +353,11 @@ function createRequestHandler(ctx) {
                 await adapter.resume(session.id, params.message);
                 return null;
             }
+            // --- Prune command (#40) ---
+            case "session.prune": {
+                const pruned = ctx.sessionTracker.pruneDeadSessions();
+                return { pruned };
+            }
             case "lock.list":
                 return ctx.lockManager.listAll();
             case "lock.acquire":
@@ -311,3 +409,6 @@ function isProcessAlive(pid) {
         return false;
     }
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/daemon/session-tracker.d.ts

@@ -25,6 +25,19 @@ export declare class SessionTracker {
      * - Any "running"/"idle" session in state whose PID is dead → mark stopped
      */
     private reapStaleEntries;
+    /**
+     * Validate all sessions on daemon startup (#40).
+     * Any session marked as "running" or "idle" whose PID is dead gets
+     * immediately marked as "stopped". This prevents unbounded growth of
+     * ghost sessions across daemon restarts.
+     */
+    validateAllSessions(): void;
+    /**
+     * Aggressively prune all clearly-dead sessions (#40).
+     * Returns the number of sessions pruned.
+     * Called via `agentctl prune` command.
+     */
+    pruneDeadSessions(): number;
     /**
      * Remove stopped sessions from state that have been stopped for more than 7 days.
      * This reduces overhead from accumulating hundreds of historical sessions.

package/dist/daemon/session-tracker.js

@@ -113,6 +113,79 @@ export class SessionTracker {
             }
         }
     }
+    /**
+     * Validate all sessions on daemon startup (#40).
+     * Any session marked as "running" or "idle" whose PID is dead gets
+     * immediately marked as "stopped". This prevents unbounded growth of
+     * ghost sessions across daemon restarts.
+     */
+    validateAllSessions() {
+        const sessions = this.state.getSessions();
+        let cleaned = 0;
+        for (const [id, record] of Object.entries(sessions)) {
+            if (record.status !== "running" && record.status !== "idle")
+                continue;
+            if (record.pid) {
+                if (!this.isProcessAlive(record.pid)) {
+                    this.state.setSession(id, {
+                        ...record,
+                        status: "stopped",
+                        stoppedAt: new Date().toISOString(),
+                    });
+                    cleaned++;
+                }
+            }
+            else {
+                // No PID recorded — can't verify, mark as stopped
+                this.state.setSession(id, {
+                    ...record,
+                    status: "stopped",
+                    stoppedAt: new Date().toISOString(),
+                });
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.error(`Validated sessions on startup: marked ${cleaned} dead sessions as stopped`);
+        }
+    }
+    /**
+     * Aggressively prune all clearly-dead sessions (#40).
+     * Returns the number of sessions pruned.
+     * Called via `agentctl prune` command.
+     */
+    pruneDeadSessions() {
+        const sessions = this.state.getSessions();
+        let pruned = 0;
+        for (const [id, record] of Object.entries(sessions)) {
+            // Remove stopped/completed/failed sessions older than 24h
+            if (record.status === "stopped" ||
+                record.status === "completed" ||
+                record.status === "failed") {
+                const stoppedAt = record.stoppedAt
+                    ? new Date(record.stoppedAt).getTime()
+                    : new Date(record.startedAt).getTime();
+                const age = Date.now() - stoppedAt;
+                if (age > 24 * 60 * 60 * 1000) {
+                    this.state.removeSession(id);
+                    pruned++;
+                }
+                continue;
+            }
+            // Remove running/idle sessions whose PID is dead
+            if (record.status === "running" || record.status === "idle") {
+                if (record.pid && !this.isProcessAlive(record.pid)) {
+                    this.state.removeSession(id);
+                    pruned++;
+                }
+                else if (!record.pid) {
+                    this.state.removeSession(id);
+                    pruned++;
+                }
+            }
+        }
+        return pruned;
+    }
     /**
      * Remove stopped sessions from state that have been stopped for more than 7 days.
      * This reduces overhead from accumulating hundreds of historical sessions.

package/dist/utils/daemon-env.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Save the current process environment to disk.
+ * Called at daemon start time when we still have the user's shell env.
+ */
+export declare function saveEnvironment(configDir: string): Promise<void>;
+/**
+ * Load the saved environment from disk.
+ * Returns undefined if the env file doesn't exist or is corrupt.
+ */
+export declare function loadSavedEnvironment(configDir: string): Promise<Record<string, string> | undefined>;
+/**
+ * Build an augmented environment for spawning subprocesses.
+ * Merges the saved daemon env with common bin paths to ensure
+ * binaries are findable even when the daemon is detached from the shell.
+ */
+export declare function buildSpawnEnv(savedEnv?: Record<string, string>, extraEnv?: Record<string, string>): Record<string, string>;

package/dist/utils/daemon-env.js

@@ -0,0 +1,85 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+const ENV_FILE = "daemon-env.json";
+/**
+ * Common bin directories that should be in PATH when spawning subprocesses.
+ * These cover the usual locations for various package managers and tools.
+ */
+function getCommonBinDirs() {
+    const home = os.homedir();
+    return [
+        path.join(home, ".local", "bin"),
+        "/usr/local/bin",
+        "/usr/bin",
+        "/bin",
+        "/usr/sbin",
+        "/sbin",
+        "/opt/homebrew/bin",
+        path.join(home, ".npm-global", "bin"),
+        path.join(home, ".local", "share", "mise", "shims"),
+        path.join(home, ".cargo", "bin"),
+    ];
+}
+/**
+ * Save the current process environment to disk.
+ * Called at daemon start time when we still have the user's shell env.
+ */
+export async function saveEnvironment(configDir) {
+    const envPath = path.join(configDir, ENV_FILE);
+    try {
+        const tmpPath = `${envPath}.tmp`;
+        await fs.writeFile(tmpPath, JSON.stringify(process.env));
+        await fs.rename(tmpPath, envPath);
+    }
+    catch (err) {
+        console.error(`Warning: could not save environment: ${err.message}`);
+    }
+}
+/**
+ * Load the saved environment from disk.
+ * Returns undefined if the env file doesn't exist or is corrupt.
+ */
+export async function loadSavedEnvironment(configDir) {
+    const envPath = path.join(configDir, ENV_FILE);
+    try {
+        const raw = await fs.readFile(envPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === "object" && parsed !== null) {
+            return parsed;
+        }
+    }
+    catch {
+        // File doesn't exist or is corrupt
+    }
+    return undefined;
+}
+/**
+ * Build an augmented environment for spawning subprocesses.
+ * Merges the saved daemon env with common bin paths to ensure
+ * binaries are findable even when the daemon is detached from the shell.
+ */
+export function buildSpawnEnv(savedEnv, extraEnv) {
+    const base = {};
+    const source = savedEnv || process.env;
+    // Copy source env
+    for (const [k, v] of Object.entries(source)) {
+        if (v !== undefined)
+            base[k] = v;
+    }
+    // Augment PATH with common bin directories
+    const existingPath = base.PATH || "";
+    const existingDirs = new Set(existingPath.split(":").filter(Boolean));
+    const commonDirs = getCommonBinDirs();
+    const newDirs = commonDirs.filter((d) => !existingDirs.has(d));
+    if (newDirs.length > 0) {
+        base.PATH = [...existingPath.split(":").filter(Boolean), ...newDirs].join(":");
+    }
+    // Apply extra env overrides
+    if (extraEnv) {
+        for (const [k, v] of Object.entries(extraEnv)) {
+            base[k] = v;
+        }
+    }
+    return base;
+}

package/dist/utils/resolve-binary.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resolve the absolute path to a binary, checking known locations first,
+ * then falling back to `which`. Results are cached per binary name.
+ *
+ * @param name - Binary name (e.g., "claude", "codex", "pi")
+ * @param knownLocations - Additional absolute paths to check first
+ * @returns Resolved absolute path, or bare name as last resort
+ */
+export declare function resolveBinaryPath(name: string, knownLocations?: string[]): Promise<string>;
+/**
+ * Clear the resolved path cache. Call this when binaries may have been
+ * updated (e.g., on daemon restart).
+ */
+export declare function clearBinaryCache(): void;

package/dist/utils/resolve-binary.js

@@ -0,0 +1,66 @@
+import { execFile } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/** Cache of resolved binary paths: name → absolute path */
+const resolvedCache = new Map();
+/**
+ * Resolve the absolute path to a binary, checking known locations first,
+ * then falling back to `which`. Results are cached per binary name.
+ *
+ * @param name - Binary name (e.g., "claude", "codex", "pi")
+ * @param knownLocations - Additional absolute paths to check first
+ * @returns Resolved absolute path, or bare name as last resort
+ */
+export async function resolveBinaryPath(name, knownLocations = []) {
+    const cached = resolvedCache.get(name);
+    if (cached)
+        return cached;
+    const home = os.homedir();
+    // Default well-known locations for common toolchains
+    const defaultLocations = [
+        path.join(home, ".local", "bin", name),
+        `/usr/local/bin/${name}`,
+        `/opt/homebrew/bin/${name}`, // Homebrew Apple Silicon
+        path.join(home, ".npm-global", "bin", name),
+        path.join(home, ".local", "share", "mise", "shims", name),
+        path.join(home, ".cargo", "bin", name),
+    ];
+    const candidates = [...knownLocations, ...defaultLocations];
+    for (const c of candidates) {
+        try {
+            await fs.access(c, fs.constants.X_OK);
+            // Resolve symlinks to get the actual binary path
+            const resolved = await fs.realpath(c);
+            await fs.access(resolved, fs.constants.X_OK);
+            resolvedCache.set(name, resolved);
+            return resolved;
+        }
+        catch {
+            // Try next
+        }
+    }
+    // Try `which <name>` as fallback
+    try {
+        const { stdout } = await execFileAsync("which", [name]);
+        const p = stdout.trim();
+        if (p) {
+            resolvedCache.set(name, p);
+            return p;
+        }
+    }
+    catch {
+        // Fall through
+    }
+    // Last resort: bare name (let PATH resolve it at spawn time)
+    return name;
+}
+/**
+ * Clear the resolved path cache. Call this when binaries may have been
+ * updated (e.g., on daemon restart).
+ */
+export function clearBinaryCache() {
+    resolvedCache.clear();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orgloop/agentctl",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Universal agent supervision interface — monitor and control AI coding agents from a single CLI",
   "type": "module",
   "bin": {