@orgloop/agentctl 1.2.0 → 1.3.0

package/dist/adapters/pi.js

@@ -5,6 +5,8 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import { buildSpawnEnv } from "../utils/daemon-env.js";
+import { resolveBinaryPath } from "../utils/resolve-binary.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_PI_DIR = path.join(os.homedir(), ".pi");
 // Default: only show stopped sessions from the last 7 days
@@ -31,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();
@@ -163,18 +203,22 @@ export class PiAdapter {
         if (opts.model) {
             args.unshift("--model", opts.model);
         }
-        const env = { ...process.env, ...opts.env };
+        const env = buildSpawnEnv(undefined, opts.env);
         const cwd = opts.cwd || process.cwd();
         // Write stdout to a log file so we can extract the session ID
         await fs.mkdir(this.sessionsMetaDir, { recursive: true });
         const logPath = path.join(this.sessionsMetaDir, `launch-${Date.now()}.log`);
         const logFd = await fs.open(logPath, "w");
-        const child = spawn("pi", args, {
+        const piPath = await resolveBinaryPath("pi");
+        const child = spawn(piPath, args, {
             cwd,
             env,
             stdio: ["ignore", logFd.fd, logFd.fd],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[pi] spawn error: ${err.message}`);
+        });
         // Fully detach: child runs in its own process group.
         child.unref();
         const pid = child.pid;
@@ -331,11 +375,15 @@ export class PiAdapter {
         // Launch a new pi session in the same cwd with the continuation message.
         const disc = await this.findSession(sessionId);
         const cwd = disc?.header.cwd || process.cwd();
-        const child = spawn("pi", ["-p", message], {
+        const piPath = await resolveBinaryPath("pi");
+        const child = spawn(piPath, ["-p", message], {
             cwd,
             stdio: ["pipe", "pipe", "pipe"],
             detached: true,
         });
+        child.on("error", (err) => {
+            console.error(`[pi] resume spawn error: ${err.message}`);
+        });
         child.unref();
     }
     async *events() {

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(),
@@ -84,6 +83,7 @@ function formatSession(s, showGroup) {
     const row = {
         ID: s.id.slice(0, 8),
         Status: s.status,
+        Adapter: s.adapter || "-",
         Model: s.model || "-",
     };
     if (showGroup)
@@ -94,10 +94,23 @@ 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),
         Status: s.status,
+        Adapter: s.adapter || "-",
         Model: s.model || "-",
     };
     if (showGroup)
@@ -176,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
@@ -212,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
@@ -418,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 ---
@@ -621,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
@@ -844,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 {
@@ -859,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()),
         })));
     }
@@ -868,6 +829,25 @@ program
         process.exit(1);
     }
 });
+// --- Prune command (#40) ---
+program
+    .command("prune")
+    .description("Remove dead and stale sessions from daemon state")
+    .action(async () => {
+    const daemonRunning = await ensureDaemon();
+    if (!daemonRunning) {
+        console.error("Daemon not running. Start with: agentctl daemon start");
+        process.exit(1);
+    }
+    try {
+        const result = await client.call("session.prune");
+        console.log(`Pruned ${result.pruned} dead/stale sessions`);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 // --- Daemon subcommand ---
 const daemonCmd = new Command("daemon").description("Manage the agentctl daemon");
 daemonCmd
@@ -945,8 +925,9 @@ daemonCmd
 });
 daemonCmd
     .command("status")
-    .description("Show daemon status")
+    .description("Show daemon status and all daemon-related processes")
     .action(async () => {
+    // Show daemon status
     try {
         const status = await client.call("daemon.status");
         console.log(`Daemon running (PID ${status.pid})`);
@@ -958,6 +939,38 @@ daemonCmd
     catch {
         console.log("Daemon not running");
     }
+    // Show all daemon-related processes (#39)
+    const configDir = path.join(os.homedir(), ".agentctl");
+    const { getSupervisorPid } = await import("./daemon/supervisor.js");
+    const supPid = await getSupervisorPid();
+    let daemonPid = null;
+    try {
+        const raw = await fs.readFile(path.join(configDir, "agentctl.pid"), "utf-8");
+        const pid = Number.parseInt(raw.trim(), 10);
+        try {
+            process.kill(pid, 0);
+            daemonPid = pid;
+        }
+        catch {
+            // PID file is stale
+        }
+    }
+    catch {
+        // No PID file
+    }
+    console.log("\nDaemon-related processes:");
+    if (supPid) {
+        console.log(`  Supervisor: PID ${supPid} (alive)`);
+    }
+    else {
+        console.log("  Supervisor: not running");
+    }
+    if (daemonPid) {
+        console.log(`  Daemon: PID ${daemonPid} (alive)`);
+    }
+    else {
+        console.log("  Daemon: not running");
+    }
 });
 daemonCmd
     .command("restart")

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;
 }