@orgloop/agentctl 1.3.0 → 1.4.0

package/dist/daemon/metrics.d.ts

@@ -1,8 +1,6 @@
 import type { FuseEngine } from "./fuse-engine.js";
 import type { LockManager } from "./lock-manager.js";
-import type { SessionTracker } from "./session-tracker.js";
 export declare class MetricsRegistry {
-    private sessionTracker;
     private lockManager;
     private fuseEngine;
     sessionsTotalCompleted: number;
@@ -10,7 +8,12 @@ export declare class MetricsRegistry {
     sessionsTotalStopped: number;
     fusesExpiredTotal: number;
     sessionDurations: number[];
-    constructor(sessionTracker: SessionTracker, lockManager: LockManager, fuseEngine: FuseEngine);
+    /** Last-known active session count, updated by session.list fan-out */
+    private _activeSessionCount;
+    constructor(lockManager: LockManager, fuseEngine: FuseEngine);
+    /** Update the active session gauge (called after session.list fan-out) */
+    setActiveSessionCount(count: number): void;
+    get activeSessionCount(): number;
     recordSessionCompleted(durationSeconds?: number): void;
     recordSessionFailed(durationSeconds?: number): void;
     recordSessionStopped(durationSeconds?: number): void;

package/dist/daemon/metrics.js

@@ -1,5 +1,4 @@
 export class MetricsRegistry {
-    sessionTracker;
     lockManager;
     fuseEngine;
     sessionsTotalCompleted = 0;
@@ -7,11 +6,19 @@ export class MetricsRegistry {
     sessionsTotalStopped = 0;
     fusesExpiredTotal = 0;
     sessionDurations = []; // seconds
-    constructor(sessionTracker, lockManager, fuseEngine) {
-        this.sessionTracker = sessionTracker;
+    /** Last-known active session count, updated by session.list fan-out */
+    _activeSessionCount = 0;
+    constructor(lockManager, fuseEngine) {
         this.lockManager = lockManager;
         this.fuseEngine = fuseEngine;
     }
+    /** Update the active session gauge (called after session.list fan-out) */
+    setActiveSessionCount(count) {
+        this._activeSessionCount = count;
+    }
+    get activeSessionCount() {
+        return this._activeSessionCount;
+    }
     recordSessionCompleted(durationSeconds) {
         this.sessionsTotalCompleted++;
         if (durationSeconds != null)
@@ -43,7 +50,7 @@ export class MetricsRegistry {
             lines.push(labels ? `${name}{${labels}} ${value}` : `${name} ${value}`);
         };
         // Gauges
-        g("agentctl_sessions_active", "Number of active sessions", this.sessionTracker.activeCount());
+        g("agentctl_sessions_active", "Number of active sessions", this._activeSessionCount);
         const locks = this.lockManager.listAll();
         g("agentctl_locks_active", "Number of active locks", locks.filter((l) => l.type === "auto").length, 'type="auto"');
         g("agentctl_locks_active", "Number of active locks", locks.filter((l) => l.type === "manual").length, 'type="manual"');

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.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,47 +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
-                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.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();
@@ -388,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[];
 }

package/dist/daemon/session-tracker.js

@@ -1,220 +1,53 @@
-/** Max age for stopped sessions in state before pruning (7 days) */
-const STOPPED_SESSION_PRUNE_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Grace period for recently-launched sessions.
+ * If a session was launched less than this many ms ago and the adapter
+ * doesn't return it yet, don't mark it stopped — the adapter may not
+ * have discovered it yet.
+ */
+const LAUNCH_GRACE_PERIOD_MS = 30_000;
+/**
+ * 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 class SessionTracker {
     state;
     adapters;
-    pollIntervalMs;
-    pollHandle = null;
-    polling = false;
     isProcessAlive;
+    cleanupHandle = null;
     constructor(state, opts) {
         this.state = state;
         this.adapters = opts.adapters;
-        this.pollIntervalMs = opts.pollIntervalMs ?? 5000;
         this.isProcessAlive = opts.isProcessAlive ?? defaultIsProcessAlive;
     }
-    startPolling() {
-        if (this.pollHandle)
-            return;
-        // Prune old stopped sessions on startup
-        this.pruneOldSessions();
-        // Initial poll
-        this.guardedPoll();
-        this.pollHandle = setInterval(() => {
-            this.guardedPoll();
-        }, this.pollIntervalMs);
-    }
-    /** Run poll() with a guard to skip if the previous cycle is still running */
-    guardedPoll() {
-        if (this.polling)
-            return;
-        this.polling = true;
-        this.poll()
-            .catch((err) => console.error("Poll error:", err))
-            .finally(() => {
-            this.polling = false;
-        });
-    }
-    stopPolling() {
-        if (this.pollHandle) {
-            clearInterval(this.pollHandle);
-            this.pollHandle = null;
-        }
-    }
-    async poll() {
-        // Collect PIDs from all adapter-discovered sessions (the source of truth)
-        const adapterPidToId = new Map();
-        for (const [adapterName, adapter] of Object.entries(this.adapters)) {
-            try {
-                // Discover-first: adapter.discover() is the ground truth
-                const discovered = await adapter.discover();
-                for (const disc of discovered) {
-                    if (disc.pid) {
-                        adapterPidToId.set(disc.pid, disc.id);
-                    }
-                    const existing = this.state.getSession(disc.id);
-                    const record = discoveredToRecord(disc, adapterName);
-                    if (!existing) {
-                        this.state.setSession(disc.id, record);
-                    }
-                    else if (existing.status !== record.status ||
-                        (!existing.model && record.model)) {
-                        // Status changed or model resolved — update, preserving metadata
-                        this.state.setSession(disc.id, {
-                            ...existing,
-                            status: record.status,
-                            stoppedAt: record.stoppedAt,
-                            model: record.model || existing.model,
-                            tokens: record.tokens,
-                            cost: record.cost,
-                            prompt: record.prompt || existing.prompt,
-                            pid: record.pid,
-                        });
-                    }
-                }
-            }
-            catch {
-                // 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
+     * 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.
      */
-    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(),
-                    });
-                }
-            }
-        }
-    }
-    /**
-     * 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++;
+    startLaunchCleanup(onDead) {
+        if (this.cleanupHandle)
+            return;
+        this.cleanupHandle = setInterval(() => {
+            const dead = this.cleanupDeadLaunches();
+            if (onDead) {
+                for (const id of dead)
+                    onDead(id);
             }
-        }
-        if (cleaned > 0) {
-            console.error(`Validated sessions on startup: marked ${cleaned} dead sessions as stopped`);
-        }
+        }, 30_000);
     }
-    /**
-     * 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++;
-                }
-            }
+    stopLaunchCleanup() {
+        if (this.cleanupHandle) {
+            clearInterval(this.cleanupHandle);
+            this.cleanupHandle = null;
         }
-        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.
-     */
-    pruneOldSessions() {
-        const sessions = this.state.getSessions();
-        const now = Date.now();
-        let pruned = 0;
-        for (const [id, record] of Object.entries(sessions)) {
-            if (record.status !== "stopped" &&
-                record.status !== "completed" &&
-                record.status !== "failed") {
-                continue;
-            }
-            const stoppedAt = record.stoppedAt
-                ? new Date(record.stoppedAt).getTime()
-                : new Date(record.startedAt).getTime();
-            if (now - stoppedAt > STOPPED_SESSION_PRUNE_AGE_MS) {
-                this.state.removeSession(id);
-                pruned++;
-            }
-        }
-        if (pruned > 0) {
-            console.error(`Pruned ${pruned} sessions stopped >7 days ago from state`);
-        }
-    }
-    /** Track a newly launched session */
+    /** Track a newly launched session (stores launch metadata in state) */
     track(session, adapterName) {
         const record = sessionToRecord(session, adapterName);
         // Pending→UUID reconciliation: if this is a real session (not pending),
@@ -229,7 +62,7 @@ export class SessionTracker {
         this.state.setSession(session.id, record);
         return record;
     }
-    /** Get session record by id (exact or prefix) */
+    /** Get session launch metadata by id (exact or prefix match) */
     getSession(id) {
         // Exact match
         const exact = this.state.getSession(id);
@@ -242,48 +75,11 @@ export class SessionTracker {
             return matches[0][1];
         return undefined;
     }
-    /** List all tracked sessions */
-    listSessions(opts) {
-        const sessions = Object.values(this.state.getSessions());
-        // Liveness check: mark sessions with dead PIDs as stopped
-        for (const s of sessions) {
-            if ((s.status === "running" || s.status === "idle") && s.pid) {
-                if (!this.isProcessAlive(s.pid)) {
-                    s.status = "stopped";
-                    s.stoppedAt = new Date().toISOString();
-                    this.state.setSession(s.id, s);
-                }
-            }
-        }
-        let filtered = sessions;
-        if (opts?.adapter) {
-            filtered = filtered.filter((s) => s.adapter === opts.adapter);
-        }
-        if (opts?.status) {
-            filtered = filtered.filter((s) => s.status === opts.status);
-        }
-        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")
-                return -1;
-            if (b.status === "running" && a.status !== "running")
-                return 1;
-            return new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime();
-        });
-    }
-    activeCount() {
-        return Object.values(this.state.getSessions()).filter((s) => s.status === "running" || s.status === "idle").length;
-    }
-    /** Remove a session from state entirely (used for ghost cleanup) */
+    /** Remove a session from launch metadata */
     removeSession(sessionId) {
         this.state.removeSession(sessionId);
     }
-    /** 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) {
         const session = this.state.getSession(sessionId);
         if (session) {
@@ -293,6 +89,91 @@ export class SessionTracker {
         }
         return session;
     }
+    /**
+     * 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, succeededAdapters) {
+        // Build lookups for discovered sessions
+        const discoveredIds = new Set(discovered.map((d) => d.id));
+        const discoveredPids = new Map();
+        for (const d of discovered) {
+            if (d.pid)
+                discoveredPids.set(d.pid, d.id);
+        }
+        // 1. Convert discovered sessions to records, enriching with launch metadata
+        const sessions = discovered.map((disc) => enrichDiscovered(disc, this.state.getSession(disc.id)));
+        // 2. Reconcile daemon-launched sessions that disappeared from adapter results
+        const stoppedLaunchIds = [];
+        const now = Date.now();
+        for (const [id, record] of Object.entries(this.state.getSessions())) {
+            if (record.status !== "running" &&
+                record.status !== "idle" &&
+                record.status !== "pending")
+                continue;
+            // If adapter for this session didn't succeed, include as-is from launch metadata
+            // (we can't verify status, so trust the last-known state)
+            if (!succeededAdapters.has(record.adapter)) {
+                sessions.push(record);
+                continue;
+            }
+            // Skip if adapter returned this session (it's still active)
+            if (discoveredIds.has(id))
+                continue;
+            // Check if this session's PID was resolved to a different ID (pending→UUID)
+            if (record.pid && discoveredPids.has(record.pid)) {
+                // PID was resolved to a real session — remove stale launch entry
+                this.state.removeSession(id);
+                stoppedLaunchIds.push(id);
+                continue;
+            }
+            // Grace period: don't mark recently-launched sessions as stopped
+            const launchAge = now - new Date(record.startedAt).getTime();
+            if (launchAge < LAUNCH_GRACE_PERIOD_MS) {
+                // Still within grace period — include as-is in results
+                sessions.push(record);
+                continue;
+            }
+            // Session disappeared from adapter results — mark stopped
+            this.state.setSession(id, {
+                ...record,
+                status: "stopped",
+                stoppedAt: new Date().toISOString(),
+            });
+            stoppedLaunchIds.push(id);
+        }
+        return { sessions, stoppedLaunchIds };
+    }
+    /**
+     * 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() {
+        const dead = [];
+        for (const [id, record] of Object.entries(this.state.getSessions())) {
+            if (record.status !== "running" &&
+                record.status !== "idle" &&
+                record.status !== "pending")
+                continue;
+            if (record.pid && !this.isProcessAlive(record.pid)) {
+                this.state.setSession(id, {
+                    ...record,
+                    status: "stopped",
+                    stoppedAt: new Date().toISOString(),
+                });
+                dead.push(id);
+            }
+        }
+        return dead;
+    }
 }
 /** Check if a process is alive via kill(pid, 0) signal check */
 function defaultIsProcessAlive(pid) {
@@ -305,22 +186,25 @@ function defaultIsProcessAlive(pid) {
     }
 }
 /**
- * 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.
+ * Convert a discovered session to a SessionRecord, enriching with launch metadata.
  */
-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 enrichDiscovered(disc, launchMeta) {
+    return {
+        id: disc.id,
+        adapter: disc.adapter,
+        status: disc.status,
+        startedAt: disc.startedAt?.toISOString() ?? new Date().toISOString(),
+        stoppedAt: disc.stoppedAt?.toISOString(),
+        cwd: disc.cwd ?? launchMeta?.cwd,
+        model: disc.model ?? launchMeta?.model,
+        prompt: disc.prompt ?? launchMeta?.prompt,
+        tokens: disc.tokens,
+        cost: disc.cost,
+        pid: disc.pid,
+        spec: launchMeta?.spec,
+        group: launchMeta?.group,
+        meta: disc.nativeMetadata ?? launchMeta?.meta ?? {},
+    };
 }
 function sessionToRecord(session, adapterName) {
     return {
@@ -340,20 +224,3 @@ function sessionToRecord(session, adapterName) {
         meta: session.meta,
     };
 }
-/** Convert a DiscoveredSession (adapter ground truth) to a SessionRecord for state */
-function discoveredToRecord(disc, adapterName) {
-    return {
-        id: disc.id,
-        adapter: adapterName,
-        status: disc.status,
-        startedAt: disc.startedAt?.toISOString() ?? new Date().toISOString(),
-        stoppedAt: disc.stoppedAt?.toISOString(),
-        cwd: disc.cwd,
-        model: disc.model,
-        prompt: disc.prompt,
-        tokens: disc.tokens,
-        cost: disc.cost,
-        pid: disc.pid,
-        meta: disc.nativeMetadata ?? {},
-    };
-}

package/package.json

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