@orgloop/agentctl 1.0.1 → 1.1.0

package/dist/adapters/claude-code.js

@@ -148,7 +148,7 @@ export class ClaudeCodeAdapter {
         if (pid) {
             resolvedSessionId = await this.pollForSessionId(logPath, pid, 5000);
         }
-        const sessionId = resolvedSessionId || crypto.randomUUID();
+        const sessionId = resolvedSessionId || (pid ? `pending-${pid}` : crypto.randomUUID());
         // Persist session metadata so status checks work after wrapper exits
         if (pid) {
             await this.writeSessionMeta({

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

@@ -3,16 +3,25 @@ import type { SessionRecord, StateManager } from "./state.js";
 export interface SessionTrackerOpts {
     adapters: Record<string, AgentAdapter>;
     pollIntervalMs?: number;
+    /** Override PID liveness check for testing (default: process.kill(pid, 0)) */
+    isProcessAlive?: (pid: number) => boolean;
 }
 export declare class SessionTracker {
     private state;
     private adapters;
     private pollIntervalMs;
     private pollHandle;
+    private readonly isProcessAlive;
     constructor(state: StateManager, opts: SessionTrackerOpts);
     startPolling(): void;
     stopPolling(): void;
     private poll;
+    /**
+     * Clean up ghost sessions in the daemon state:
+     * - pending-* entries whose PID matches a resolved session → remove pending
+     * - Any "running"/"idle" session in state whose PID is dead → mark stopped
+     */
+    private reapStaleEntries;
     /** Track a newly launched session */
     track(session: AgentSession, adapterName: string): SessionRecord;
     /** Get session record by id (exact or prefix) */

package/dist/daemon/session-tracker.js

@@ -3,10 +3,12 @@ export class SessionTracker {
     adapters;
     pollIntervalMs;
     pollHandle = null;
+    isProcessAlive;
     constructor(state, opts) {
         this.state = state;
         this.adapters = opts.adapters;
         this.pollIntervalMs = opts.pollIntervalMs ?? 5000;
+        this.isProcessAlive = opts.isProcessAlive ?? defaultIsProcessAlive;
     }
     startPolling() {
         if (this.pollHandle)
@@ -24,10 +26,15 @@ export class SessionTracker {
         }
     }
     async poll() {
+        // Collect PIDs from all adapter-returned sessions (the source of truth)
+        const adapterPidToId = new Map();
         for (const [adapterName, adapter] of Object.entries(this.adapters)) {
             try {
                 const sessions = await adapter.list({ all: true });
                 for (const session of sessions) {
+                    if (session.pid) {
+                        adapterPidToId.set(session.pid, session.id);
+                    }
                     const existing = this.state.getSession(session.id);
                     const record = sessionToRecord(session, adapterName);
                     if (!existing) {
@@ -49,6 +56,43 @@ export class SessionTracker {
                 // Adapter unavailable — skip
             }
         }
+        // Reap stale entries from daemon state
+        this.reapStaleEntries(adapterPidToId);
+    }
+    /**
+     * Clean up ghost sessions in the daemon state:
+     * - pending-* entries whose PID matches a resolved session → remove pending
+     * - Any "running"/"idle" session in state whose PID is dead → mark stopped
+     */
+    reapStaleEntries(adapterPidToId) {
+        const sessions = this.state.getSessions();
+        for (const [id, record] of Object.entries(sessions)) {
+            // Bug 2: If this is a pending-* entry and a real session has the same PID,
+            // the pending entry is stale — remove it
+            if (id.startsWith("pending-") && record.pid) {
+                const resolvedId = adapterPidToId.get(record.pid);
+                if (resolvedId && resolvedId !== id) {
+                    this.state.removeSession(id);
+                    continue;
+                }
+            }
+            // Bug 1: If session is "running"/"idle" but PID is dead, mark stopped
+            if ((record.status === "running" || record.status === "idle") &&
+                record.pid) {
+                // Only reap if the adapter didn't return this session as running
+                // (adapter is the source of truth for sessions it knows about)
+                const adapterId = adapterPidToId.get(record.pid);
+                if (adapterId === id)
+                    continue; // Adapter confirmed this PID is active
+                if (!this.isProcessAlive(record.pid)) {
+                    this.state.setSession(id, {
+                        ...record,
+                        status: "stopped",
+                        stoppedAt: new Date().toISOString(),
+                    });
+                }
+            }
+        }
     }
     /** Track a newly launched session */
     track(session, adapterName) {
@@ -79,6 +123,8 @@ export class SessionTracker {
         else if (!opts?.all) {
             filtered = filtered.filter((s) => s.status === "running" || s.status === "idle");
         }
+        // Dedup: if a pending-* entry shares a PID with a resolved entry, show only the resolved one
+        filtered = deduplicatePendingSessions(filtered);
         return filtered.sort((a, b) => {
             // Running first, then by recency
             if (a.status === "running" && b.status !== "running")
@@ -102,6 +148,34 @@ export class SessionTracker {
         return session;
     }
 }
+/** Check if a process is alive via kill(pid, 0) signal check */
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove pending-* entries that share a PID with a resolved (non-pending) session.
+ * This is a safety net for list output — the poll() reaper handles cleanup in state.
+ */
+function deduplicatePendingSessions(sessions) {
+    const realPids = new Set();
+    for (const s of sessions) {
+        if (!s.id.startsWith("pending-") && s.pid) {
+            realPids.add(s.pid);
+        }
+    }
+    return sessions.filter((s) => {
+        if (s.id.startsWith("pending-") && s.pid && realPids.has(s.pid)) {
+            return false;
+        }
+        return true;
+    });
+}
 function sessionToRecord(session, adapterName) {
     return {
         id: session.id,

package/package.json

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