@orgloop/agentctl 1.2.1 → 1.4.0

package/dist/daemon/server.js

@@ -60,17 +60,25 @@ export async function startDaemon(opts = {}) {
         emitter,
     });
     const sessionTracker = new SessionTracker(state, { adapters });
-    const metrics = new MetricsRegistry(sessionTracker, lockManager, fuseEngine);
+    const metrics = new MetricsRegistry(lockManager, fuseEngine);
     // Wire up events
-    emitter.on("fuse.fired", () => {
-        metrics.recordFuseFired();
+    emitter.on("fuse.expired", () => {
+        metrics.recordFuseExpired();
     });
-    // 9. Validate all sessions on startup — mark dead ones as stopped (#40)
-    sessionTracker.validateAllSessions();
+    // 9. Initial PID liveness cleanup for daemon-launched sessions
+    //    (replaces the old validateAllSessions — much simpler, only checks launches)
+    const initialDead = sessionTracker.cleanupDeadLaunches();
+    if (initialDead.length > 0) {
+        for (const id of initialDead)
+            lockManager.autoUnlock(id);
+        console.error(`Startup cleanup: marked ${initialDead.length} dead launches as stopped`);
+    }
     // 10. Resume fuse timers
     fuseEngine.resumeTimers();
-    // 11. Start session polling
-    sessionTracker.startPolling();
+    // 11. Start periodic PID liveness check for lock cleanup (30s interval)
+    sessionTracker.startLaunchCleanup((deadId) => {
+        lockManager.autoUnlock(deadId);
+    });
     // 12. Create request handler
     const handleRequest = createRequestHandler({
         sessionTracker,
@@ -140,7 +148,7 @@ export async function startDaemon(opts = {}) {
     });
     // Shutdown function
     const shutdown = async () => {
-        sessionTracker.stopPolling();
+        sessionTracker.stopLaunchCleanup();
         fuseEngine.shutdown();
         state.flush();
         await state.persist();
@@ -247,20 +255,104 @@ function createRequestHandler(ctx) {
         const params = (req.params || {});
         switch (req.method) {
             case "session.list": {
-                let sessions = ctx.sessionTracker.listSessions({
-                    status: params.status,
-                    all: params.all,
-                });
-                if (params.group) {
-                    sessions = sessions.filter((s) => s.group === params.group);
+                const adapterFilter = params.adapter;
+                const statusFilter = params.status;
+                const showAll = params.all;
+                const groupFilter = params.group;
+                // Fan out discover() to adapters (or just one if filtered)
+                const adapterEntries = adapterFilter
+                    ? Object.entries(ctx.adapters).filter(([name]) => name === adapterFilter)
+                    : Object.entries(ctx.adapters);
+                const ADAPTER_TIMEOUT_MS = 5000;
+                const succeededAdapters = new Set();
+                const results = await Promise.allSettled(adapterEntries.map(([name, adapter]) => Promise.race([
+                    adapter.discover().then((sessions) => {
+                        succeededAdapters.add(name);
+                        return sessions.map((s) => ({ ...s, adapter: name }));
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Adapter ${name} timed out`)), ADAPTER_TIMEOUT_MS)),
+                ])));
+                // Merge fulfilled results, skip failed adapters
+                const discovered = results
+                    .filter((r) => r.status === "fulfilled")
+                    .flatMap((r) => r.value);
+                // Reconcile with launch metadata and enrich
+                const { sessions: allSessions, stoppedLaunchIds } = ctx.sessionTracker.reconcileAndEnrich(discovered, succeededAdapters);
+                // Release locks for sessions that disappeared from adapter results
+                for (const id of stoppedLaunchIds) {
+                    ctx.lockManager.autoUnlock(id);
+                }
+                // Apply filters
+                let sessions = allSessions;
+                if (statusFilter) {
+                    sessions = sessions.filter((s) => s.status === statusFilter);
                 }
+                else if (!showAll) {
+                    sessions = sessions.filter((s) => s.status === "running" || s.status === "idle");
+                }
+                if (groupFilter) {
+                    sessions = sessions.filter((s) => s.group === groupFilter);
+                }
+                // Sort: running first, then by most recent
+                sessions.sort((a, b) => {
+                    if (a.status === "running" && b.status !== "running")
+                        return -1;
+                    if (b.status === "running" && a.status !== "running")
+                        return 1;
+                    return (new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+                });
+                // Update metrics gauge
+                ctx.metrics.setActiveSessionCount(allSessions.filter((s) => s.status === "running" || s.status === "idle").length);
                 return sessions;
             }
             case "session.status": {
-                const session = ctx.sessionTracker.getSession(params.id);
-                if (!session)
-                    throw new Error(`Session not found: ${params.id}`);
-                return session;
+                const id = params.id;
+                // Check launch metadata to determine adapter
+                const launchRecord = ctx.sessionTracker.getSession(id);
+                const adapterName = params.adapter || launchRecord?.adapter;
+                // Determine which adapters to search
+                const adaptersToSearch = adapterName
+                    ? Object.entries(ctx.adapters).filter(([name]) => name === adapterName)
+                    : Object.entries(ctx.adapters);
+                // Search adapters for the session
+                for (const [name, adapter] of adaptersToSearch) {
+                    try {
+                        const discovered = await adapter.discover();
+                        let match = discovered.find((d) => d.id === id);
+                        // Prefix match
+                        if (!match) {
+                            const prefixMatches = discovered.filter((d) => d.id.startsWith(id));
+                            if (prefixMatches.length === 1)
+                                match = prefixMatches[0];
+                        }
+                        if (match) {
+                            const meta = ctx.sessionTracker.getSession(match.id);
+                            return {
+                                id: match.id,
+                                adapter: name,
+                                status: match.status,
+                                startedAt: match.startedAt?.toISOString() ?? new Date().toISOString(),
+                                stoppedAt: match.stoppedAt?.toISOString(),
+                                cwd: match.cwd ?? meta?.cwd,
+                                model: match.model ?? meta?.model,
+                                prompt: match.prompt ?? meta?.prompt,
+                                tokens: match.tokens,
+                                cost: match.cost,
+                                pid: match.pid,
+                                spec: meta?.spec,
+                                group: meta?.group,
+                                meta: match.nativeMetadata ?? meta?.meta ?? {},
+                            };
+                        }
+                    }
+                    catch {
+                        // Adapter failed — try next
+                    }
+                }
+                // Fall back to launch metadata if adapters didn't find it
+                if (launchRecord)
+                    return launchRecord;
+                throw new Error(`Session not found: ${id}`);
             }
             case "session.peek": {
                 // Auto-detect adapter from tracked session, fall back to param or claude-code
@@ -315,48 +407,57 @@ function createRequestHandler(ctx) {
                 return record;
             }
             case "session.stop": {
-                const session = ctx.sessionTracker.getSession(params.id);
-                if (!session)
-                    throw new Error(`Session not found: ${params.id}`);
+                const id = params.id;
+                const launchRecord = ctx.sessionTracker.getSession(id);
                 // Ghost pending entry with dead PID: remove from state with --force
-                if (session.id.startsWith("pending-") &&
+                if (launchRecord?.id.startsWith("pending-") &&
                     params.force &&
-                    session.pid &&
-                    !isProcessAlive(session.pid)) {
-                    ctx.lockManager.autoUnlock(session.id);
-                    ctx.sessionTracker.removeSession(session.id);
+                    launchRecord.pid &&
+                    !isProcessAlive(launchRecord.pid)) {
+                    ctx.lockManager.autoUnlock(launchRecord.id);
+                    ctx.sessionTracker.removeSession(launchRecord.id);
                     return null;
                 }
-                const adapter = ctx.adapters[session.adapter];
+                const adapterName = params.adapter || launchRecord?.adapter;
+                if (!adapterName)
+                    throw new Error(`Session not found: ${id}. Specify --adapter to stop a non-daemon session.`);
+                const adapter = ctx.adapters[adapterName];
                 if (!adapter)
-                    throw new Error(`Unknown adapter: ${session.adapter}`);
-                await adapter.stop(session.id, {
+                    throw new Error(`Unknown adapter: ${adapterName}`);
+                const sessionId = launchRecord?.id || id;
+                await adapter.stop(sessionId, {
                     force: params.force,
                 });
                 // Remove auto-lock
-                ctx.lockManager.autoUnlock(session.id);
-                // Mark stopped and start fuse if applicable
-                const stopped = ctx.sessionTracker.onSessionExit(session.id);
+                ctx.lockManager.autoUnlock(sessionId);
+                // Mark stopped in launch metadata
+                const stopped = ctx.sessionTracker.onSessionExit(sessionId);
                 if (stopped) {
-                    ctx.fuseEngine.onSessionExit(stopped);
                     ctx.metrics.recordSessionStopped();
                 }
                 return null;
             }
             case "session.resume": {
-                const session = ctx.sessionTracker.getSession(params.id);
-                if (!session)
-                    throw new Error(`Session not found: ${params.id}`);
-                const adapter = ctx.adapters[session.adapter];
+                const id = params.id;
+                const launchRecord = ctx.sessionTracker.getSession(id);
+                const adapterName = params.adapter || launchRecord?.adapter;
+                if (!adapterName)
+                    throw new Error(`Session not found: ${id}. Specify --adapter to resume a non-daemon session.`);
+                const adapter = ctx.adapters[adapterName];
                 if (!adapter)
-                    throw new Error(`Unknown adapter: ${session.adapter}`);
-                await adapter.resume(session.id, params.message);
+                    throw new Error(`Unknown adapter: ${adapterName}`);
+                await adapter.resume(launchRecord?.id || id, params.message);
                 return null;
             }
-            // --- Prune command (#40) ---
+            // --- Prune command (#40) --- kept for CLI backward compat
             case "session.prune": {
-                const pruned = ctx.sessionTracker.pruneDeadSessions();
-                return { pruned };
+                // In the stateless model, there's no session registry to prune.
+                // Clean up dead launches (PID liveness check) as a best-effort action.
+                const deadIds = ctx.sessionTracker.cleanupDeadLaunches();
+                for (const id of deadIds) {
+                    ctx.lockManager.autoUnlock(id);
+                }
+                return { pruned: deadIds.length };
             }
             case "lock.list":
                 return ctx.lockManager.listAll();
@@ -367,6 +468,21 @@ function createRequestHandler(ctx) {
                 return null;
             case "fuse.list":
                 return ctx.fuseEngine.listActive();
+            case "fuse.set":
+                ctx.fuseEngine.setFuse({
+                    directory: params.directory,
+                    sessionId: params.sessionId,
+                    ttlMs: params.ttlMs,
+                    onExpire: params.onExpire,
+                    label: params.label,
+                });
+                return null;
+            case "fuse.extend": {
+                const extended = ctx.fuseEngine.extendFuse(params.directory, params.ttlMs);
+                if (!extended)
+                    throw new Error(`No active fuse for directory: ${params.directory}`);
+                return null;
+            }
             case "fuse.cancel":
                 ctx.fuseEngine.cancelFuse(params.directory);
                 return null;
@@ -374,7 +490,7 @@ function createRequestHandler(ctx) {
                 return {
                     pid: process.pid,
                     uptime: Date.now() - startTime,
-                    sessions: ctx.sessionTracker.activeCount(),
+                    sessions: ctx.metrics.activeSessionCount,
                     locks: ctx.lockManager.listAll().length,
                     fuses: ctx.fuseEngine.listActive().length,
                 };

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

@@ -1,61 +1,60 @@
-import type { AgentAdapter, AgentSession } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession } from "../core/types.js";
 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;
 }
+/**
+ * Simplified session tracker for the stateless daemon core (ADR 004).
+ *
+ * Adapters own session truth. The daemon only tracks:
+ * - Launch metadata (prompt, group, spec, cwd) for sessions launched via agentctl
+ * - Locks and fuses (handled by LockManager / FuseEngine)
+ *
+ * The old polling loop, pruning, and state-based session registry are removed.
+ * session.list now fans out adapter.discover() at call time.
+ */
 export declare class SessionTracker {
     private state;
     private adapters;
-    private pollIntervalMs;
-    private pollHandle;
-    private polling;
     private readonly isProcessAlive;
+    private cleanupHandle;
     constructor(state: StateManager, opts: SessionTrackerOpts);
-    startPolling(): void;
-    /** Run poll() with a guard to skip if the previous cycle is still running */
-    private guardedPoll;
-    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
+     * Start periodic PID liveness check for daemon-launched sessions.
+     * This is a lightweight check (no adapter fan-out) that runs every 30s
+     * to detect dead sessions and return their IDs for lock cleanup.
      */
-    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.
-     */
-    private pruneOldSessions;
-    /** Track a newly launched session */
+    startLaunchCleanup(onDead?: (sessionId: string) => void): void;
+    stopLaunchCleanup(): void;
+    /** Track a newly launched session (stores launch metadata in state) */
     track(session: AgentSession, adapterName: string): SessionRecord;
-    /** Get session record by id (exact or prefix) */
+    /** Get session launch metadata by id (exact or prefix match) */
     getSession(id: string): SessionRecord | undefined;
-    /** List all tracked sessions */
-    listSessions(opts?: {
-        status?: string;
-        all?: boolean;
-        adapter?: string;
-    }): SessionRecord[];
-    activeCount(): number;
-    /** Remove a session from state entirely (used for ghost cleanup) */
+    /** Remove a session from launch metadata */
     removeSession(sessionId: string): void;
-    /** Called when a session stops — returns the cwd for fuse/lock processing */
+    /** Called when a session stops — marks it in launch metadata, returns the record */
     onSessionExit(sessionId: string): SessionRecord | undefined;
+    /**
+     * Merge adapter-discovered sessions with daemon launch metadata.
+     *
+     * 1. Enrich discovered sessions with launch metadata (prompt, group, spec, etc.)
+     * 2. Reconcile: mark daemon-launched sessions as stopped if their adapter
+     *    succeeded but didn't return them (and they're past the grace period).
+     * 3. Include recently-launched sessions that adapters haven't discovered yet.
+     *
+     * Returns the merged session list and IDs of sessions that were marked stopped
+     * (for lock cleanup by the caller).
+     */
+    reconcileAndEnrich(discovered: DiscoveredSession[], succeededAdapters: Set<string>): {
+        sessions: SessionRecord[];
+        stoppedLaunchIds: string[];
+    };
+    /**
+     * Check PID liveness for daemon-launched sessions.
+     * Returns IDs of sessions whose PIDs have died.
+     * This is a lightweight check (no adapter fan-out) for lock cleanup.
+     */
+    cleanupDeadLaunches(): string[];
 }