@orgloop/agentctl 1.2.1 → 1.4.0

package/dist/cli.js

@@ -18,7 +18,6 @@ import { DaemonClient } from "./client/daemon-client.js";
 import { runHook } from "./hooks.js";
 import { orchestrateLaunch, parseAdapterSlots, } from "./launch-orchestrator.js";
 import { expandMatrix, parseMatrixFile } from "./matrix-parser.js";
-import { mergeSession } from "./merge.js";
 import { createWorktree } from "./worktree.js";
 const adapters = {
     "claude-code": new ClaudeCodeAdapter(),
@@ -95,6 +94,18 @@ function formatSession(s, showGroup) {
     row.Prompt = (s.prompt || "-").slice(0, 60);
     return row;
 }
+function formatDiscovered(s) {
+    return {
+        ID: s.id.slice(0, 8),
+        Adapter: s.adapter,
+        Status: s.status,
+        Model: s.model || "-",
+        CWD: s.cwd ? shortenPath(s.cwd) : "-",
+        PID: s.pid?.toString() || "-",
+        Started: s.startedAt ? timeAgo(s.startedAt) : "-",
+        Prompt: (s.prompt || "-").slice(0, 60),
+    };
+}
 function formatRecord(s, showGroup) {
     const row = {
         ID: s.id.slice(0, 8),
@@ -178,6 +189,22 @@ function sessionToJson(s) {
         meta: s.meta,
     };
 }
+function discoveredToJson(s) {
+    return {
+        id: s.id,
+        adapter: s.adapter,
+        status: s.status,
+        startedAt: s.startedAt?.toISOString(),
+        stoppedAt: s.stoppedAt?.toISOString(),
+        cwd: s.cwd,
+        model: s.model,
+        prompt: s.prompt,
+        tokens: s.tokens,
+        cost: s.cost,
+        pid: s.pid,
+        nativeMetadata: s.nativeMetadata,
+    };
+}
 // --- CLI ---
 const program = new Command();
 program
@@ -214,25 +241,40 @@ program
         }
         return;
     }
-    // Direct fallback
-    const listOpts = { status: opts.status, all: opts.all };
-    let sessions = [];
+    // Direct fallback — discover-first
+    let discovered = [];
     if (opts.adapter) {
         const adapter = getAdapter(opts.adapter);
-        sessions = await adapter.list(listOpts);
+        discovered = await adapter.discover();
     }
     else {
         for (const adapter of getAllAdapters()) {
-            const s = await adapter.list(listOpts);
-            sessions.push(...s);
+            const d = await adapter.discover().catch(() => []);
+            discovered.push(...d);
         }
     }
+    // Apply status/all filters
+    if (opts.status) {
+        discovered = discovered.filter((s) => s.status === opts.status);
+    }
+    else if (!opts.all) {
+        discovered = discovered.filter((s) => s.status === "running");
+    }
+    // Sort: running first, then by most recent
+    discovered.sort((a, b) => {
+        if (a.status === "running" && b.status !== "running")
+            return -1;
+        if (b.status === "running" && a.status !== "running")
+            return 1;
+        const aTime = a.startedAt?.getTime() ?? 0;
+        const bTime = b.startedAt?.getTime() ?? 0;
+        return bTime - aTime;
+    });
     if (opts.json) {
-        printJson(sessions.map(sessionToJson));
+        printJson(discovered.map(discoveredToJson));
     }
     else {
-        const hasGroups = sessions.some((s) => s.group);
-        printTable(sessions.map((s) => formatSession(s, hasGroups)));
+        printTable(discovered.map((s) => formatDiscovered(s)));
     }
 });
 // status
@@ -420,18 +462,14 @@ program
     .option("--matrix <file>", "YAML matrix file for advanced sweep launch")
     .option("--on-create <script>", "Hook: run after session is created")
     .option("--on-complete <script>", "Hook: run after session completes")
-    .option("--pre-merge <script>", "Hook: run before merge")
-    .option("--post-merge <script>", "Hook: run after merge")
     .allowUnknownOption() // Allow interleaved --adapter/--model for parseAdapterSlots
     .action(async (adapterName, opts) => {
     let cwd = opts.cwd ? path.resolve(opts.cwd) : process.cwd();
     // Collect hooks
-    const hooks = opts.onCreate || opts.onComplete || opts.preMerge || opts.postMerge
+    const hooks = opts.onCreate || opts.onComplete
         ? {
             onCreate: opts.onCreate,
             onComplete: opts.onComplete,
-            preMerge: opts.preMerge,
-            postMerge: opts.postMerge,
         }
         : undefined;
     // --- Multi-adapter / matrix detection ---
@@ -623,85 +661,6 @@ program
         console.log(JSON.stringify(out));
     }
 });
-// --- Merge command (FEAT-4) ---
-program
-    .command("merge <id>")
-    .description("Commit, push, and open PR for a session's work")
-    .option("-m, --message <text>", "Commit message")
-    .option("--remove-worktree", "Remove worktree after merge")
-    .option("--repo <path>", "Main repo path (for worktree removal)")
-    .option("--pre-merge <script>", "Hook: run before merge")
-    .option("--post-merge <script>", "Hook: run after merge")
-    .action(async (id, opts) => {
-    // Find session
-    const daemonRunning = await ensureDaemon();
-    let sessionCwd;
-    let sessionAdapter;
-    if (daemonRunning) {
-        try {
-            const session = await client.call("session.status", {
-                id,
-            });
-            sessionCwd = session.cwd;
-            sessionAdapter = session.adapter;
-        }
-        catch {
-            // Fall through to adapter
-        }
-    }
-    if (!sessionCwd) {
-        const adapter = getAdapter();
-        try {
-            const session = await adapter.status(id);
-            sessionCwd = session.cwd;
-            sessionAdapter = session.adapter;
-        }
-        catch (err) {
-            console.error(`Session not found: ${err.message}`);
-            process.exit(1);
-        }
-    }
-    if (!sessionCwd) {
-        console.error("Cannot determine session working directory");
-        process.exit(1);
-    }
-    const hooks = opts.preMerge || opts.postMerge
-        ? { preMerge: opts.preMerge, postMerge: opts.postMerge }
-        : undefined;
-    // Pre-merge hook
-    if (hooks?.preMerge) {
-        await runHook(hooks, "preMerge", {
-            sessionId: id,
-            cwd: sessionCwd,
-            adapter: sessionAdapter || "claude-code",
-        });
-    }
-    const result = await mergeSession({
-        cwd: sessionCwd,
-        message: opts.message,
-        removeWorktree: opts.removeWorktree,
-        repoPath: opts.repo,
-    });
-    if (result.committed)
-        console.log("Changes committed");
-    if (result.pushed)
-        console.log("Pushed to remote");
-    if (result.prUrl)
-        console.log(`PR: ${result.prUrl}`);
-    if (result.worktreeRemoved)
-        console.log("Worktree removed");
-    if (!result.committed && !result.pushed) {
-        console.log("No changes to commit or push");
-    }
-    // Post-merge hook
-    if (hooks?.postMerge) {
-        await runHook(hooks, "postMerge", {
-            sessionId: id,
-            cwd: sessionCwd,
-            adapter: sessionAdapter || "claude-code",
-        });
-    }
-});
 // --- Worktree subcommand ---
 const worktreeCmd = new Command("worktree").description("Manage agentctl-created worktrees");
 worktreeCmd
@@ -846,7 +805,7 @@ program
 // --- Fuses command ---
 program
     .command("fuses")
-    .description("List active Kind cluster fuse timers")
+    .description("List active fuse timers")
     .option("--json", "Output as JSON")
     .action(async (opts) => {
     try {
@@ -861,7 +820,7 @@ program
         }
         printTable(fuses.map((f) => ({
             Directory: shortenPath(f.directory),
-            Cluster: f.clusterName,
+            Label: f.label || "-",
             "Expires In": formatDuration(new Date(f.expiresAt).getTime() - Date.now()),
         })));
     }

package/dist/core/types.d.ts

@@ -1,5 +1,31 @@
+/**
+ * Session discovered by an adapter's runtime — the ground truth for "what exists."
+ * This is the source of truth for session lifecycle in the discover-first model.
+ */
+export interface DiscoveredSession {
+    id: string;
+    status: "running" | "stopped";
+    adapter: string;
+    cwd?: string;
+    model?: string;
+    startedAt?: Date;
+    stoppedAt?: Date;
+    pid?: number;
+    prompt?: string;
+    tokens?: {
+        in: number;
+        out: number;
+    };
+    cost?: number;
+    /** Adapter-native fields — whatever the runtime provides */
+    nativeMetadata?: Record<string, unknown>;
+}
 export interface AgentAdapter {
     id: string;
+    /** Find all sessions currently managed by this adapter's runtime. */
+    discover(): Promise<DiscoveredSession[]>;
+    /** Check if a specific session is still alive. */
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;
@@ -64,6 +90,4 @@ export interface LaunchOpts {
 export interface LifecycleHooks {
     onCreate?: string;
     onComplete?: string;
-    preMerge?: string;
-    postMerge?: string;
 }

package/dist/daemon/fuse-engine.d.ts

@@ -1,28 +1,31 @@
 import type { EventEmitter } from "node:events";
-import type { FuseTimer, SessionRecord, StateManager } from "./state.js";
+import type { FuseTimer, StateManager } from "./state.js";
 export interface FuseEngineOpts {
     defaultDurationMs: number;
     emitter?: EventEmitter;
 }
+export interface SetFuseOpts {
+    directory: string;
+    sessionId: string;
+    ttlMs?: number;
+    onExpire?: FuseTimer["onExpire"];
+    label?: string;
+}
 export declare class FuseEngine {
     private timers;
     private state;
     private defaultDurationMs;
     private emitter?;
     constructor(state: StateManager, opts: FuseEngineOpts);
-    /** Derive cluster name from worktree directory. Returns null if not a mono worktree. */
-    static deriveClusterName(directory: string): {
-        clusterName: string;
-        branch: string;
-    } | null;
-    /** Called when a session exits. Starts fuse if applicable. */
-    onSessionExit(session: SessionRecord): void;
-    private startFuse;
+    /** Set a fuse for a directory. Called when a session exits or explicitly via API. */
+    setFuse(opts: SetFuseOpts): void;
+    /** Extend an existing fuse's TTL. Resets the timer to a new duration. */
+    extendFuse(directory: string, ttlMs?: number): boolean;
     /** Cancel fuse for a directory. */
     cancelFuse(directory: string, persist?: boolean): boolean;
     /** Resume fuses from persisted state after daemon restart. */
     resumeTimers(): void;
-    /** Fire a fuse — delete the Kind cluster. */
+    /** Fire a fuse — execute the configured on-expire action. */
     private fireFuse;
     listActive(): FuseTimer[];
     /** Clear all timers (for clean shutdown) */

package/dist/daemon/fuse-engine.js

@@ -1,6 +1,4 @@
 import { exec } from "node:child_process";
-import os from "node:os";
-import path from "node:path";
 import { promisify } from "node:util";
 const execAsync = promisify(exec);
 export class FuseEngine {
@@ -13,43 +11,45 @@ export class FuseEngine {
         this.defaultDurationMs = opts.defaultDurationMs;
         this.emitter = opts.emitter;
     }
-    /** Derive cluster name from worktree directory. Returns null if not a mono worktree. */
-    static deriveClusterName(directory) {
-        const home = os.homedir();
-        const monoPrefix = path.join(home, "code", "mono-");
-        if (!directory.startsWith(monoPrefix))
-            return null;
-        const branch = directory.slice(monoPrefix.length);
-        if (!branch)
-            return null;
-        return {
-            clusterName: `kindo-charlie-${branch}`,
-            branch,
+    /** Set a fuse for a directory. Called when a session exits or explicitly via API. */
+    setFuse(opts) {
+        const ttlMs = opts.ttlMs ?? this.defaultDurationMs;
+        // Cancel existing fuse for same directory
+        this.cancelFuse(opts.directory, false);
+        const expiresAt = new Date(Date.now() + ttlMs);
+        const fuse = {
+            directory: opts.directory,
+            ttlMs,
+            expiresAt: expiresAt.toISOString(),
+            sessionId: opts.sessionId,
+            onExpire: opts.onExpire,
+            label: opts.label,
         };
+        this.state.addFuse(fuse);
+        const timeout = setTimeout(() => this.fireFuse(fuse), ttlMs);
+        this.timers.set(opts.directory, timeout);
+        this.emitter?.emit("fuse.set", fuse);
     }
-    /** Called when a session exits. Starts fuse if applicable. */
-    onSessionExit(session) {
-        if (!session.cwd)
-            return;
-        const derived = FuseEngine.deriveClusterName(session.cwd);
-        if (!derived)
-            return;
-        this.startFuse(session.cwd, derived.clusterName, derived.branch, session.id);
-    }
-    startFuse(directory, clusterName, branch, sessionId) {
-        // Cancel existing fuse for same directory
+    /** Extend an existing fuse's TTL. Resets the timer to a new duration. */
+    extendFuse(directory, ttlMs) {
+        const existing = this.state
+            .getFuses()
+            .find((f) => f.directory === directory);
+        if (!existing)
+            return false;
+        const duration = ttlMs ?? existing.ttlMs;
         this.cancelFuse(directory, false);
-        const expiresAt = new Date(Date.now() + this.defaultDurationMs);
+        const expiresAt = new Date(Date.now() + duration);
         const fuse = {
-            directory,
-            clusterName,
-            branch,
+            ...existing,
+            ttlMs: duration,
             expiresAt: expiresAt.toISOString(),
-            sessionId,
         };
         this.state.addFuse(fuse);
-        const timeout = setTimeout(() => this.fireFuse(fuse), this.defaultDurationMs);
+        const timeout = setTimeout(() => this.fireFuse(fuse), duration);
         this.timers.set(directory, timeout);
+        this.emitter?.emit("fuse.extended", fuse);
+        return true;
     }
     /** Cancel fuse for a directory. */
     cancelFuse(directory, persist = true) {
@@ -79,30 +79,53 @@ export class FuseEngine {
             }
         }
     }
-    /** Fire a fuse — delete the Kind cluster. */
+    /** Fire a fuse — execute the configured on-expire action. */
     async fireFuse(fuse) {
         this.timers.delete(fuse.directory);
         this.state.removeFuse(fuse.directory);
-        console.log(`Fuse fired: deleting cluster ${fuse.clusterName}`);
-        try {
-            // Best effort: yarn local:down first
+        const label = fuse.label || fuse.directory;
+        console.log(`Fuse expired: ${label}`);
+        this.emitter?.emit("fuse.expired", fuse);
+        const action = fuse.onExpire;
+        if (!action)
+            return;
+        // Execute on-expire script
+        if (action.script) {
             try {
-                await execAsync("yarn local:down", {
+                await execAsync(action.script, {
                     cwd: fuse.directory,
-                    timeout: 60_000,
+                    timeout: 120_000,
+                });
+                console.log(`Fuse action completed: ${label}`);
+            }
+            catch (err) {
+                console.error(`Fuse action failed for ${label}:`, err);
+            }
+        }
+        // POST to webhook
+        if (action.webhook) {
+            try {
+                const body = JSON.stringify({
+                    type: "fuse.expired",
+                    directory: fuse.directory,
+                    sessionId: fuse.sessionId,
+                    label: fuse.label,
+                    expiredAt: new Date().toISOString(),
+                });
+                await fetch(action.webhook, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body,
+                    signal: AbortSignal.timeout(30_000),
                 });
             }
-            catch {
-                // Ignore
+            catch (err) {
+                console.error(`Fuse webhook failed for ${label}:`, err);
             }
-            await execAsync(`kind delete cluster --name ${fuse.clusterName}`, {
-                timeout: 120_000,
-            });
-            console.log(`Cluster ${fuse.clusterName} deleted`);
-            this.emitter?.emit("fuse.fired", fuse);
         }
-        catch (err) {
-            console.error(`Failed to delete cluster ${fuse.clusterName}:`, err);
+        // Emit named event
+        if (action.event) {
+            this.emitter?.emit(action.event, fuse);
         }
     }
     listActive() {

package/dist/daemon/metrics.d.ts

@@ -1,20 +1,22 @@
 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;
     sessionsTotalFailed: number;
     sessionsTotalStopped: number;
-    fusesFiredTotal: number;
-    clustersDeletedTotal: 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;
-    recordFuseFired(): void;
+    recordFuseExpired(): void;
     generateMetrics(): string;
 }

package/dist/daemon/metrics.js

@@ -1,18 +1,24 @@
 export class MetricsRegistry {
-    sessionTracker;
     lockManager;
     fuseEngine;
     sessionsTotalCompleted = 0;
     sessionsTotalFailed = 0;
     sessionsTotalStopped = 0;
-    fusesFiredTotal = 0;
-    clustersDeletedTotal = 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)
@@ -28,9 +34,8 @@ export class MetricsRegistry {
         if (durationSeconds != null)
             this.sessionDurations.push(durationSeconds);
     }
-    recordFuseFired() {
-        this.fusesFiredTotal++;
-        this.clustersDeletedTotal++;
+    recordFuseExpired() {
+        this.fusesExpiredTotal++;
     }
     generateMetrics() {
         const lines = [];
@@ -45,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"');
@@ -54,8 +59,7 @@ export class MetricsRegistry {
         c("agentctl_sessions_total", "Total sessions by status", this.sessionsTotalCompleted, 'status="completed"');
         c("agentctl_sessions_total", "Total sessions by status", this.sessionsTotalFailed, 'status="failed"');
         c("agentctl_sessions_total", "Total sessions by status", this.sessionsTotalStopped, 'status="stopped"');
-        c("agentctl_fuses_fired_total", "Total fuses fired", this.fusesFiredTotal);
-        c("agentctl_kind_clusters_deleted_total", "Total Kind clusters deleted", this.clustersDeletedTotal);
+        c("agentctl_fuses_expired_total", "Total fuses expired", this.fusesExpiredTotal);
         // Histogram (session duration)
         lines.push("# HELP agentctl_session_duration_seconds Session duration histogram");
         lines.push("# TYPE agentctl_session_duration_seconds histogram");