@orgloop/agentctl 1.2.1 → 1.4.0

package/dist/daemon/session-tracker.js

@@ -1,218 +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-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) {
-                        this.state.setSession(session.id, record);
-                    }
-                    else if (existing.status !== record.status ||
-                        (!existing.model && record.model)) {
-                        // Status changed or model resolved — update
-                        this.state.setSession(session.id, {
-                            ...existing,
-                            status: record.status,
-                            stoppedAt: record.stoppedAt,
-                            model: record.model || existing.model,
-                            tokens: record.tokens,
-                            cost: record.cost,
-                            prompt: record.prompt || existing.prompt,
-                        });
-                    }
-                }
-            }
-            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
-     */
-    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.
+     * 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.
      */
-    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),
@@ -227,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);
@@ -240,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) {
@@ -291,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) {
@@ -303,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 {

package/dist/daemon/state.d.ts

@@ -28,10 +28,20 @@ export interface Lock {
 }
 export interface FuseTimer {
     directory: string;
-    clusterName: string;
-    branch: string;
+    ttlMs: number;
     expiresAt: string;
     sessionId: string;
+    /** On-expire action: shell command, webhook URL, or event name */
+    onExpire?: FuseAction;
+    label?: string;
+}
+export interface FuseAction {
+    /** Shell script to run when fuse expires. CWD is the fuse directory. */
+    script?: string;
+    /** Webhook URL to POST to when fuse expires */
+    webhook?: string;
+    /** Event name to emit when fuse expires */
+    event?: string;
 }
 export interface PersistedState {
     sessions: Record<string, SessionRecord>;

package/dist/hooks.d.ts

@@ -1,5 +1,5 @@
 import type { LifecycleHooks } from "./core/types.js";
-export type HookPhase = "onCreate" | "onComplete" | "preMerge" | "postMerge";
+export type HookPhase = "onCreate" | "onComplete";
 export interface HookContext {
     sessionId: string;
     cwd: string;

package/package.json

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

package/dist/merge.d.ts

@@ -1,24 +0,0 @@
-export interface MergeOpts {
-    /** Working directory of the session */
-    cwd: string;
-    /** Commit message (auto-generated if omitted) */
-    message?: string;
-    /** Whether to remove worktree after push */
-    removeWorktree?: boolean;
-    /** The main repo path (needed for worktree removal) */
-    repoPath?: string;
-}
-export interface MergeResult {
-    committed: boolean;
-    pushed: boolean;
-    prUrl?: string;
-    worktreeRemoved: boolean;
-}
-/**
- * Merge + cleanup workflow:
- * 1. Commit uncommitted changes
- * 2. Push to remote
- * 3. Open PR via `gh`
- * 4. Optionally remove worktree
- */
-export declare function mergeSession(opts: MergeOpts): Promise<MergeResult>;

package/dist/merge.js

@@ -1,65 +0,0 @@
-import { exec, execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execAsync = promisify(exec);
-const execFileAsync = promisify(execFile);
-/**
- * Merge + cleanup workflow:
- * 1. Commit uncommitted changes
- * 2. Push to remote
- * 3. Open PR via `gh`
- * 4. Optionally remove worktree
- */
-export async function mergeSession(opts) {
-    const { cwd } = opts;
-    const result = {
-        committed: false,
-        pushed: false,
-        worktreeRemoved: false,
-    };
-    // 1. Check for uncommitted changes
-    const { stdout: status } = await execFileAsync("git", ["status", "--porcelain"], { cwd });
-    if (status.trim()) {
-        // Stage all changes and commit
-        await execFileAsync("git", ["add", "-A"], { cwd });
-        const message = opts.message || "chore: commit agent session work (via agentctl merge)";
-        await execFileAsync("git", ["commit", "-m", message], { cwd });
-        result.committed = true;
-    }
-    // 2. Get current branch name
-    const { stdout: branchRaw } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
-    const branch = branchRaw.trim();
-    // 3. Push to remote
-    try {
-        await execFileAsync("git", ["push", "-u", "origin", branch], { cwd });
-        result.pushed = true;
-    }
-    catch (err) {
-        console.error("Push failed:", err.message);
-        return result;
-    }
-    // 4. Open PR via gh (best effort)
-    try {
-        const { stdout: prOut } = await execAsync(`gh pr create --fill --head ${branch} 2>&1 || gh pr view --json url -q .url 2>&1`, { cwd });
-        // Extract URL from output
-        const urlMatch = prOut.match(/https:\/\/github\.com\/[^\s]+/);
-        if (urlMatch) {
-            result.prUrl = urlMatch[0];
-        }
-    }
-    catch {
-        // gh not available or PR already exists
-    }
-    // 5. Optionally remove worktree
-    if (opts.removeWorktree && opts.repoPath) {
-        try {
-            await execFileAsync("git", ["worktree", "remove", "--force", cwd], {
-                cwd: opts.repoPath,
-            });
-            result.worktreeRemoved = true;
-        }
-        catch (err) {
-            console.error("Worktree removal failed:", err.message);
-        }
-    }
-    return result;
-}