@orgloop/agentctl 1.2.1 → 1.3.0

package/dist/adapters/claude-code.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -38,6 +38,8 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: ClaudeCodeAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/claude-code.js

@@ -32,6 +32,57 @@ export class ClaudeCodeAdapter {
         this.getPids = opts?.getPids || getClaudePids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const results = [];
+        let projectDirs;
+        try {
+            projectDirs = await fs.readdir(this.projectsDir);
+        }
+        catch {
+            return [];
+        }
+        for (const projDir of projectDirs) {
+            const projPath = path.join(this.projectsDir, projDir);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const entries = await this.getEntriesForProject(projPath, projDir);
+            for (const { entry, index } of entries) {
+                if (entry.isSidechain)
+                    continue;
+                const isRunning = await this.isSessionRunning(entry, index, runningPids);
+                const { model, tokens } = await this.parseSessionTail(entry.fullPath);
+                results.push({
+                    id: entry.sessionId,
+                    status: isRunning ? "running" : "stopped",
+                    adapter: this.id,
+                    cwd: index.originalPath || entry.projectPath,
+                    model,
+                    startedAt: new Date(entry.created),
+                    stoppedAt: isRunning ? undefined : new Date(entry.modified),
+                    pid: isRunning
+                        ? await this.findMatchingPid(entry, index, runningPids)
+                        : undefined,
+                    prompt: entry.firstPrompt?.slice(0, 200),
+                    tokens,
+                    nativeMetadata: {
+                        projectDir: index.originalPath || entry.projectPath,
+                        gitBranch: entry.gitBranch,
+                        messageCount: entry.messageCount,
+                    },
+                });
+            }
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const entry = await this.findIndexEntry(sessionId);
+        if (!entry)
+            return false;
+        return this.isSessionRunning(entry.entry, entry.index, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessions = [];

package/dist/adapters/codex.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface CodexPidInfo {
     pid: number;
     cwd: string;
@@ -34,6 +34,8 @@ export declare class CodexAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: CodexAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/codex.js

@@ -30,6 +30,41 @@ export class CodexAdapter {
         this.getPids = opts?.getPids || getCodexPids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const sessionInfos = await this.discoverSessions();
+        const results = [];
+        for (const info of sessionInfos) {
+            const isRunning = this.isSessionRunning(info, runningPids);
+            const pid = isRunning
+                ? this.findMatchingPid(info, runningPids)
+                : undefined;
+            results.push({
+                id: info.id,
+                status: isRunning ? "running" : "stopped",
+                adapter: this.id,
+                cwd: info.cwd,
+                model: info.model,
+                startedAt: info.created,
+                stoppedAt: isRunning ? undefined : info.modified,
+                pid,
+                prompt: info.firstPrompt,
+                tokens: info.tokens,
+                nativeMetadata: {
+                    cliVersion: info.cliVersion,
+                    lastMessage: info.lastMessage,
+                },
+            });
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const info = await this.findSession(sessionId);
+        if (!info)
+            return false;
+        return this.isSessionRunning(info, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessionInfos = await this.discoverSessions();

package/dist/adapters/openclaw.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface DeviceIdentity {
     deviceId: string;
     publicKeyPem: string;
@@ -122,6 +122,8 @@ export declare class OpenClawAdapter implements AgentAdapter {
     private readonly rpcCall;
     constructor(opts?: OpenClawAdapterOpts);
     private tryLoadDeviceIdentity;
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/openclaw.js

@@ -197,6 +197,62 @@ export class OpenClawAdapter {
             return null;
         }
     }
+    async discover() {
+        if (!this.authToken)
+            return [];
+        let result;
+        try {
+            result = (await this.rpcCall("sessions.list", {
+                includeDerivedTitles: true,
+                includeLastMessage: true,
+            }));
+        }
+        catch {
+            return [];
+        }
+        return result.sessions.map((row) => {
+            const updatedAt = row.updatedAt ?? 0;
+            const model = row.model || result.defaults.model || undefined;
+            const input = row.inputTokens ?? 0;
+            const output = row.outputTokens ?? 0;
+            // Gateway is the source of truth: if a session is in the list, it's alive.
+            // Don't guess from timestamps — sessions can be idle for hours between messages.
+            return {
+                id: row.sessionId || row.key,
+                status: "running",
+                adapter: this.id,
+                model,
+                startedAt: updatedAt > 0 ? new Date(updatedAt) : new Date(),
+                prompt: row.derivedTitle || row.displayName || row.label,
+                tokens: input || output ? { in: input, out: output } : undefined,
+                nativeMetadata: {
+                    key: row.key,
+                    kind: row.kind,
+                    channel: row.channel,
+                    displayName: row.displayName,
+                    modelProvider: row.modelProvider || result.defaults.modelProvider,
+                    lastMessagePreview: row.lastMessagePreview,
+                },
+            };
+        });
+    }
+    async isAlive(sessionId) {
+        if (!this.authToken)
+            return false;
+        try {
+            const result = (await this.rpcCall("sessions.list", {
+                search: sessionId,
+            }));
+            // Gateway is the source of truth: if a session is in the list, it's alive.
+            return result.sessions.some((s) => s.sessionId === sessionId ||
+                s.key === sessionId ||
+                s.sessionId?.startsWith(sessionId) ||
+                s.key.startsWith(sessionId));
+        }
+        catch {
+            return false;
+        }
+    }
     async list(opts) {
         if (!this.authToken) {
             console.warn("Warning: OPENCLAW_GATEWAY_TOKEN is not set — OpenClaw adapter cannot authenticate. " +
@@ -342,17 +398,18 @@ export class OpenClawAdapter {
     }
     // --- Private helpers ---
     mapRowToSession(row, defaults) {
-        const now = Date.now();
         const updatedAt = row.updatedAt ?? 0;
-        const ageMs = now - updatedAt;
-        const isActive = updatedAt > 0 && ageMs < 5 * 60 * 1000;
+        const ageMs = Date.now() - updatedAt;
+        // Gateway is the source of truth: if a session is in the list, it's alive.
+        // Use "running" for recently active sessions, "idle" for quiet ones.
+        const status = updatedAt > 0 && ageMs < 5 * 60 * 1000 ? "running" : "idle";
         const model = row.model || defaults.model || undefined;
         const input = row.inputTokens ?? 0;
         const output = row.outputTokens ?? 0;
         return {
             id: row.sessionId || row.key,
             adapter: this.id,
-            status: isActive ? "running" : "idle",
+            status,
             startedAt: updatedAt > 0 ? new Date(updatedAt) : new Date(),
             cwd: undefined,
             model,

package/dist/adapters/opencode.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -95,6 +95,8 @@ export declare class OpenCodeAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: OpenCodeAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/opencode.js

@@ -39,6 +39,63 @@ export class OpenCodeAdapter {
         this.getPids = opts?.getPids || getOpenCodePids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const results = [];
+        let projectDirs;
+        try {
+            projectDirs = await fs.readdir(this.sessionDir);
+        }
+        catch {
+            return [];
+        }
+        for (const projHash of projectDirs) {
+            const projPath = path.join(this.sessionDir, projHash);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const sessionFiles = await this.getSessionFilesForProject(projPath);
+            for (const sessionData of sessionFiles) {
+                const isRunning = await this.isSessionRunning(sessionData, runningPids);
+                const { model, tokens, cost } = await this.aggregateMessageStats(sessionData.id);
+                const createdAt = sessionData.time?.created
+                    ? new Date(sessionData.time.created)
+                    : new Date();
+                const updatedAt = sessionData.time?.updated
+                    ? new Date(sessionData.time.updated)
+                    : undefined;
+                results.push({
+                    id: sessionData.id,
+                    status: isRunning ? "running" : "stopped",
+                    adapter: this.id,
+                    cwd: sessionData.directory,
+                    model,
+                    startedAt: createdAt,
+                    stoppedAt: isRunning ? undefined : updatedAt,
+                    pid: isRunning
+                        ? await this.findMatchingPid(sessionData, runningPids)
+                        : undefined,
+                    prompt: sessionData.title?.slice(0, 200),
+                    tokens,
+                    cost,
+                    nativeMetadata: {
+                        projectID: sessionData.projectID,
+                        slug: sessionData.slug,
+                        summary: sessionData.summary,
+                        version: sessionData.version,
+                    },
+                });
+            }
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const resolved = await this.resolveSessionId(sessionId);
+        if (!resolved)
+            return false;
+        return this.isSessionRunning(resolved, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessions = [];

package/dist/adapters/pi-rust.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -41,6 +41,8 @@ export declare class PiRustAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: PiRustAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/pi-rust.js

@@ -33,6 +33,80 @@ export class PiRustAdapter {
         this.getPids = opts?.getPids || getPiRustPids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const results = [];
+        let projectDirs;
+        try {
+            const entries = await fs.readdir(this.sessionDir);
+            projectDirs = entries.filter((e) => e.startsWith("--"));
+        }
+        catch {
+            return [];
+        }
+        for (const projDir of projectDirs) {
+            const projPath = path.join(this.sessionDir, projDir);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const projectCwd = decodeProjDir(projDir);
+            const sessionFiles = await this.getSessionFiles(projPath);
+            for (const file of sessionFiles) {
+                const filePath = path.join(projPath, file);
+                const header = await this.readSessionHeader(filePath);
+                if (!header)
+                    continue;
+                const isRunning = await this.isSessionRunning(header, projectCwd, runningPids);
+                const { model, tokens, cost } = await this.parseSessionTail(filePath);
+                const firstPrompt = await this.readFirstPrompt(filePath);
+                let fileStat;
+                try {
+                    fileStat = await fs.stat(filePath);
+                }
+                catch {
+                    // ignore
+                }
+                results.push({
+                    id: header.id,
+                    status: isRunning ? "running" : "stopped",
+                    adapter: this.id,
+                    cwd: header.cwd || projectCwd,
+                    model: model || header.modelId,
+                    startedAt: new Date(header.timestamp),
+                    stoppedAt: isRunning
+                        ? undefined
+                        : fileStat
+                            ? new Date(Number(fileStat.mtimeMs))
+                            : undefined,
+                    pid: isRunning
+                        ? await this.findMatchingPid(header, projectCwd, runningPids)
+                        : undefined,
+                    prompt: firstPrompt?.slice(0, 200),
+                    tokens,
+                    cost: cost ?? undefined,
+                    nativeMetadata: {
+                        provider: header.provider,
+                        thinkingLevel: header.thinkingLevel,
+                        projectDir: projectCwd,
+                        sessionFile: filePath,
+                    },
+                });
+            }
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const filePath = await this.findSessionFile(sessionId);
+        if (!filePath)
+            return false;
+        const header = await this.readSessionHeader(filePath);
+        if (!header)
+            return false;
+        const projDir = path.basename(path.dirname(filePath));
+        const projectCwd = decodeProjDir(projDir);
+        return this.isSessionRunning(header, projectCwd, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessions = [];

package/dist/adapters/pi.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -41,6 +41,8 @@ export declare class PiAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: PiAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     /** Extract assistant messages from a JSONL session file */

package/dist/adapters/pi.js

@@ -33,6 +33,44 @@ export class PiAdapter {
         this.getPids = opts?.getPids || getPiPids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const discovered = await this.discoverSessions();
+        const results = [];
+        for (const disc of discovered) {
+            const isRunning = await this.isSessionRunning(disc, runningPids);
+            const { model, tokens, cost } = await this.parseSessionTail(disc.filePath, disc.header);
+            results.push({
+                id: disc.sessionId,
+                status: isRunning ? "running" : "stopped",
+                adapter: this.id,
+                cwd: disc.header.cwd,
+                model,
+                startedAt: disc.created,
+                stoppedAt: isRunning ? undefined : disc.modified,
+                pid: isRunning
+                    ? await this.findMatchingPid(disc, runningPids)
+                    : undefined,
+                prompt: await this.getFirstPrompt(disc.filePath),
+                tokens,
+                cost,
+                nativeMetadata: {
+                    provider: disc.header.provider,
+                    thinkingLevel: disc.header.thinkingLevel,
+                    version: disc.header.version,
+                    cwdSlug: disc.cwdSlug,
+                },
+            });
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const disc = await this.findSession(sessionId);
+        if (!disc)
+            return false;
+        return this.isSessionRunning(disc, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const discovered = await this.discoverSessions();

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

@@ -8,13 +8,12 @@ export declare class MetricsRegistry {
     sessionsTotalCompleted: number;
     sessionsTotalFailed: number;
     sessionsTotalStopped: number;
-    fusesFiredTotal: number;
-    clustersDeletedTotal: number;
+    fusesExpiredTotal: number;
     sessionDurations: number[];
     constructor(sessionTracker: SessionTracker, lockManager: LockManager, fuseEngine: FuseEngine);
     recordSessionCompleted(durationSeconds?: number): void;
     recordSessionFailed(durationSeconds?: number): void;
     recordSessionStopped(durationSeconds?: number): void;
-    recordFuseFired(): void;
+    recordFuseExpired(): void;
     generateMetrics(): string;
 }

package/dist/daemon/metrics.js

@@ -5,8 +5,7 @@ export class MetricsRegistry {
     sessionsTotalCompleted = 0;
     sessionsTotalFailed = 0;
     sessionsTotalStopped = 0;
-    fusesFiredTotal = 0;
-    clustersDeletedTotal = 0;
+    fusesExpiredTotal = 0;
     sessionDurations = []; // seconds
     constructor(sessionTracker, lockManager, fuseEngine) {
         this.sessionTracker = sessionTracker;
@@ -28,9 +27,8 @@ export class MetricsRegistry {
         if (durationSeconds != null)
             this.sessionDurations.push(durationSeconds);
     }
-    recordFuseFired() {
-        this.fusesFiredTotal++;
-        this.clustersDeletedTotal++;
+    recordFuseExpired() {
+        this.fusesExpiredTotal++;
     }
     generateMetrics() {
         const lines = [];
@@ -54,8 +52,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");

package/dist/daemon/server.js

@@ -62,8 +62,8 @@ export async function startDaemon(opts = {}) {
     const sessionTracker = new SessionTracker(state, { adapters });
     const metrics = new MetricsRegistry(sessionTracker, 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();
@@ -335,10 +335,9 @@ function createRequestHandler(ctx) {
                 });
                 // Remove auto-lock
                 ctx.lockManager.autoUnlock(session.id);
-                // Mark stopped and start fuse if applicable
+                // Mark stopped
                 const stopped = ctx.sessionTracker.onSessionExit(session.id);
                 if (stopped) {
-                    ctx.fuseEngine.onSessionExit(stopped);
                     ctx.metrics.recordSessionStopped();
                 }
                 return null;
@@ -367,6 +366,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;

package/dist/daemon/session-tracker.js

@@ -42,24 +42,25 @@ export class SessionTracker {
         }
     }
     async poll() {
-        // Collect PIDs from all adapter-returned sessions (the source of truth)
+        // 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 {
-                const sessions = await adapter.list({ all: true });
-                for (const session of sessions) {
-                    if (session.pid) {
-                        adapterPidToId.set(session.pid, session.id);
+                // 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(session.id);
-                    const record = sessionToRecord(session, adapterName);
+                    const existing = this.state.getSession(disc.id);
+                    const record = discoveredToRecord(disc, adapterName);
                     if (!existing) {
-                        this.state.setSession(session.id, record);
+                        this.state.setSession(disc.id, record);
                     }
                     else if (existing.status !== record.status ||
                         (!existing.model && record.model)) {
-                        // Status changed or model resolved — update
-                        this.state.setSession(session.id, {
+                        // Status changed or model resolved — update, preserving metadata
+                        this.state.setSession(disc.id, {
                             ...existing,
                             status: record.status,
                             stoppedAt: record.stoppedAt,
@@ -67,6 +68,7 @@ export class SessionTracker {
                             tokens: record.tokens,
                             cost: record.cost,
                             prompt: record.prompt || existing.prompt,
+                            pid: record.pid,
                         });
                     }
                 }
@@ -338,3 +340,20 @@ 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/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.3.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;
-}