@orgloop/agentctl 1.0.1 → 1.2.0

package/dist/cli.js

@@ -9,21 +9,34 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import { ClaudeCodeAdapter } from "./adapters/claude-code.js";
+import { CodexAdapter } from "./adapters/codex.js";
 import { OpenClawAdapter } from "./adapters/openclaw.js";
+import { OpenCodeAdapter } from "./adapters/opencode.js";
+import { PiAdapter } from "./adapters/pi.js";
+import { PiRustAdapter } from "./adapters/pi-rust.js";
 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(),
+    codex: new CodexAdapter(),
     openclaw: new OpenClawAdapter(),
+    opencode: new OpenCodeAdapter(),
+    pi: new PiAdapter(),
+    "pi-rust": new PiRustAdapter(),
 };
 const client = new DaemonClient();
 /**
  * Ensure the daemon is running. Auto-starts it if not.
  * Returns true if daemon is available after the call.
+ * Set AGENTCTL_NO_DAEMON=1 to skip daemon and use direct adapter mode.
  */
 async function ensureDaemon() {
+    if (process.env.AGENTCTL_NO_DAEMON === "1")
+        return false;
     if (await client.isRunning())
         return true;
     // Auto-start daemon in background
@@ -67,27 +80,33 @@ function getAllAdapters() {
     return Object.values(adapters);
 }
 // --- Formatters ---
-function formatSession(s) {
-    return {
+function formatSession(s, showGroup) {
+    const row = {
         ID: s.id.slice(0, 8),
         Status: s.status,
         Model: s.model || "-",
-        CWD: s.cwd ? shortenPath(s.cwd) : "-",
-        PID: s.pid?.toString() || "-",
-        Started: timeAgo(s.startedAt),
-        Prompt: (s.prompt || "-").slice(0, 60),
     };
+    if (showGroup)
+        row.Group = s.group || "-";
+    row.CWD = s.cwd ? shortenPath(s.cwd) : "-";
+    row.PID = s.pid?.toString() || "-";
+    row.Started = timeAgo(s.startedAt);
+    row.Prompt = (s.prompt || "-").slice(0, 60);
+    return row;
 }
-function formatRecord(s) {
-    return {
+function formatRecord(s, showGroup) {
+    const row = {
         ID: s.id.slice(0, 8),
         Status: s.status,
         Model: s.model || "-",
-        CWD: s.cwd ? shortenPath(s.cwd) : "-",
-        PID: s.pid?.toString() || "-",
-        Started: timeAgo(new Date(s.startedAt)),
-        Prompt: (s.prompt || "-").slice(0, 60),
     };
+    if (showGroup)
+        row.Group = s.group || "-";
+    row.CWD = s.cwd ? shortenPath(s.cwd) : "-";
+    row.PID = s.pid?.toString() || "-";
+    row.Started = timeAgo(new Date(s.startedAt));
+    row.Prompt = (s.prompt || "-").slice(0, 60);
+    return row;
 }
 function shortenPath(p) {
     const home = process.env.HOME || "";
@@ -153,6 +172,7 @@ function sessionToJson(s) {
         tokens: s.tokens,
         cost: s.cost,
         pid: s.pid,
+        group: s.group,
         meta: s.meta,
     };
 }
@@ -168,20 +188,27 @@ program
     .description("List agent sessions")
     .option("--adapter <name>", "Filter by adapter")
     .option("--status <status>", "Filter by status (running|stopped|idle|error)")
+    .option("--group <id>", "Filter by launch group (e.g. g-a1b2c3)")
     .option("-a, --all", "Include stopped sessions (last 7 days)")
     .option("--json", "Output as JSON")
     .action(async (opts) => {
     const daemonRunning = await ensureDaemon();
     if (daemonRunning) {
-        const sessions = await client.call("session.list", {
+        let sessions = await client.call("session.list", {
             status: opts.status,
             all: opts.all,
+            adapter: opts.adapter,
+            group: opts.group,
         });
+        if (opts.adapter) {
+            sessions = sessions.filter((s) => s.adapter === opts.adapter);
+        }
         if (opts.json) {
             printJson(sessions);
         }
         else {
-            printTable(sessions.map(formatRecord));
+            const hasGroups = sessions.some((s) => s.group);
+            printTable(sessions.map((s) => formatRecord(s, hasGroups)));
         }
         return;
     }
@@ -202,7 +229,8 @@ program
         printJson(sessions.map(sessionToJson));
     }
     else {
-        printTable(sessions.map(formatSession));
+        const hasGroups = sessions.some((s) => s.group);
+        printTable(sessions.map((s) => formatSession(s, hasGroups)));
     }
 });
 // status
@@ -222,7 +250,7 @@ program
                 printJson(session);
             }
             else {
-                const fmt = formatRecord(session);
+                const fmt = formatRecord(session, !!session.group);
                 for (const [k, v] of Object.entries(fmt)) {
                     console.log(`${k.padEnd(10)} ${v}`);
                 }
@@ -232,32 +260,37 @@ program
             }
             return;
         }
-        catch (err) {
-            console.error(err.message);
-            process.exit(1);
+        catch {
+            // Daemon failed — fall through to direct adapter lookup
         }
     }
-    // Direct fallback
-    const adapter = getAdapter(opts.adapter);
-    try {
-        const session = await adapter.status(id);
-        if (opts.json) {
-            printJson(sessionToJson(session));
-        }
-        else {
-            const fmt = formatSession(session);
-            for (const [k, v] of Object.entries(fmt)) {
-                console.log(`${k.padEnd(10)} ${v}`);
+    // Direct fallback: try specified adapter, or search all adapters
+    const statusAdapters = opts.adapter
+        ? [getAdapter(opts.adapter)]
+        : getAllAdapters();
+    for (const adapter of statusAdapters) {
+        try {
+            const session = await adapter.status(id);
+            if (opts.json) {
+                printJson(sessionToJson(session));
             }
-            if (session.tokens) {
-                console.log(`Tokens     in: ${session.tokens.in}, out: ${session.tokens.out}`);
+            else {
+                const fmt = formatSession(session, !!session.group);
+                for (const [k, v] of Object.entries(fmt)) {
+                    console.log(`${k.padEnd(10)} ${v}`);
+                }
+                if (session.tokens) {
+                    console.log(`Tokens     in: ${session.tokens.in}, out: ${session.tokens.out}`);
+                }
             }
+            return;
+        }
+        catch {
+            // Try next adapter
         }
     }
-    catch (err) {
-        console.error(err.message);
-        process.exit(1);
-    }
+    console.error(`Session not found: ${id}`);
+    process.exit(1);
 });
 // peek
 program
@@ -276,22 +309,39 @@ program
             console.log(output);
             return;
         }
+        catch {
+            // Daemon failed — fall through to direct adapter lookup
+        }
+    }
+    // Direct fallback: try specified adapter, or search all adapters
+    if (opts.adapter) {
+        const adapter = getAdapter(opts.adapter);
+        try {
+            const output = await adapter.peek(id, {
+                lines: Number.parseInt(opts.lines, 10),
+            });
+            console.log(output);
+            return;
+        }
         catch (err) {
             console.error(err.message);
             process.exit(1);
         }
     }
-    const adapter = getAdapter(opts.adapter);
-    try {
-        const output = await adapter.peek(id, {
-            lines: Number.parseInt(opts.lines, 10),
-        });
-        console.log(output);
-    }
-    catch (err) {
-        console.error(err.message);
-        process.exit(1);
+    for (const adapter of getAllAdapters()) {
+        try {
+            const output = await adapter.peek(id, {
+                lines: Number.parseInt(opts.lines, 10),
+            });
+            console.log(output);
+            return;
+        }
+        catch {
+            // Try next adapter
+        }
     }
+    console.error(`Session not found: ${id}`);
+    process.exit(1);
 });
 // stop
 program
@@ -356,7 +406,7 @@ program
 // launch
 program
     .command("launch [adapter]")
-    .description("Launch a new agent session")
+    .description("Launch a new agent session (or multiple with --adapter flags)")
     .requiredOption("-p, --prompt <text>", "Prompt to send")
     .option("--spec <path>", "Spec file path")
     .option("--cwd <dir>", "Working directory")
@@ -364,13 +414,108 @@ program
     .option("--force", "Override directory locks")
     .option("--worktree <repo>", "Auto-create git worktree from this repo before launch")
     .option("--branch <name>", "Branch name for --worktree")
+    .option("--adapter <name>", "Adapter to launch (repeatable for parallel launch)", collectAdapter, [])
+    .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();
-    const name = adapterName || "claude-code";
+    // Collect hooks
+    const hooks = opts.onCreate || opts.onComplete || opts.preMerge || opts.postMerge
+        ? {
+            onCreate: opts.onCreate,
+            onComplete: opts.onComplete,
+            preMerge: opts.preMerge,
+            postMerge: opts.postMerge,
+        }
+        : undefined;
+    // --- Multi-adapter / matrix detection ---
+    let slots = [];
+    if (opts.matrix) {
+        // Matrix file mode
+        try {
+            const matrixFile = await parseMatrixFile(opts.matrix);
+            slots = expandMatrix(matrixFile);
+            // Matrix can override cwd and prompt
+            if (matrixFile.cwd)
+                cwd = path.resolve(matrixFile.cwd);
+        }
+        catch (err) {
+            console.error(`Failed to parse matrix file: ${err.message}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Check for multi-adapter via raw argv parsing
+        // We need raw argv because commander can't handle interleaved
+        // --adapter A --model M1 --adapter B --model M2
+        const rawArgs = process.argv.slice(2);
+        const adapterCount = rawArgs.filter((a) => a === "--adapter" || a === "-A").length;
+        if (adapterCount > 1) {
+            // Multi-adapter mode: parse from raw args
+            slots = parseAdapterSlots(rawArgs);
+        }
+        else if (adapterCount === 1 && opts.adapter?.length === 1) {
+            // Single --adapter flag — could still be multi if model is specified
+            // but this is the normal single-adapter path via --adapter flag
+        }
+    }
+    // --- Parallel launch path ---
+    if (slots.length > 1) {
+        const daemonRunning = await ensureDaemon();
+        try {
+            let groupId = "";
+            const result = await orchestrateLaunch({
+                slots,
+                prompt: opts.prompt,
+                spec: opts.spec,
+                cwd,
+                hooks,
+                adapters,
+                onSessionLaunched: (slotResult) => {
+                    // Track in daemon if available
+                    if (daemonRunning && !slotResult.error) {
+                        client
+                            .call("session.launch.track", {
+                            id: slotResult.sessionId,
+                            adapter: slotResult.slot.adapter,
+                            cwd: slotResult.cwd,
+                            group: groupId,
+                        })
+                            .catch(() => {
+                            // Best effort — session will be picked up by poll
+                        });
+                    }
+                },
+                onGroupCreated: (id) => {
+                    groupId = id;
+                },
+            });
+            console.log(`\nLaunched ${result.results.length} sessions (group: ${result.groupId}):`);
+            for (const r of result.results) {
+                const label = r.slot.model
+                    ? `${r.slot.adapter} (${r.slot.model})`
+                    : r.slot.adapter;
+                if (r.error) {
+                    console.log(`  ✗ ${label} — ${r.error}`);
+                }
+                else {
+                    console.log(`  ${label}  → ${shortenPath(r.cwd)}  (${r.sessionId.slice(0, 8)})`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Parallel launch failed: ${err.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    // --- Single adapter launch path (original behavior) ---
+    const name = slots.length === 1 ? slots[0].adapter : adapterName || "claude-code";
+    const model = slots.length === 1 && slots[0].model ? slots[0].model : opts.model;
     // FEAT-1: Worktree lifecycle
     let worktreeInfo;
     if (opts.worktree) {
@@ -391,15 +536,6 @@ program
             process.exit(1);
         }
     }
-    // Collect hooks
-    const hooks = opts.onCreate || opts.onComplete || opts.preMerge || opts.postMerge
-        ? {
-            onCreate: opts.onCreate,
-            onComplete: opts.onComplete,
-            preMerge: opts.preMerge,
-            postMerge: opts.postMerge,
-        }
-        : undefined;
     const daemonRunning = await ensureDaemon();
     if (daemonRunning) {
         try {
@@ -408,7 +544,7 @@ program
                 prompt: opts.prompt,
                 cwd,
                 spec: opts.spec,
-                model: opts.model,
+                model,
                 force: opts.force,
                 worktree: worktreeInfo
                     ? { repo: worktreeInfo.repo, branch: worktreeInfo.branch }
@@ -443,7 +579,7 @@ program
             prompt: opts.prompt,
             spec: opts.spec,
             cwd,
-            model: opts.model,
+            model,
             hooks,
         });
         console.log(`Launched session ${session.id.slice(0, 8)} (PID: ${session.pid})`);
@@ -462,6 +598,10 @@ program
         process.exit(1);
     }
 });
+/** Commander collect callback for repeatable --adapter */
+function collectAdapter(value, previous) {
+    return previous.concat([value]);
+}
 // events
 program
     .command("events")
@@ -560,6 +700,84 @@ program
         });
     }
 });
+// --- Worktree subcommand ---
+const worktreeCmd = new Command("worktree").description("Manage agentctl-created worktrees");
+worktreeCmd
+    .command("list")
+    .description("List git worktrees for a repo")
+    .argument("<repo>", "Path to the main repo")
+    .option("--json", "Output as JSON")
+    .action(async (repo, opts) => {
+    const { listWorktrees } = await import("./worktree.js");
+    try {
+        const entries = await listWorktrees(repo);
+        // Filter to only non-bare worktrees (exclude the main worktree)
+        const worktrees = entries.filter((e) => !e.bare);
+        if (opts.json) {
+            printJson(worktrees);
+            return;
+        }
+        if (worktrees.length === 0) {
+            console.log("No worktrees found.");
+            return;
+        }
+        printTable(worktrees.map((e) => ({
+            Path: shortenPath(e.path),
+            Branch: e.branch || "-",
+            HEAD: e.head?.slice(0, 8) || "-",
+        })));
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+worktreeCmd
+    .command("clean")
+    .description("Remove a worktree and optionally its branch")
+    .argument("<path>", "Path to the worktree to remove")
+    .option("--repo <path>", "Main repo path (auto-detected if omitted)")
+    .option("--delete-branch", "Also delete the worktree's branch")
+    .action(async (worktreePath, opts) => {
+    const { cleanWorktree } = await import("./worktree.js");
+    const absPath = path.resolve(worktreePath);
+    let repo = opts.repo;
+    // Auto-detect repo from the worktree's .git file
+    if (!repo) {
+        try {
+            const gitFile = await fs.readFile(path.join(absPath, ".git"), "utf-8");
+            // .git file contains: gitdir: /path/to/repo/.git/worktrees/<name>
+            const match = gitFile.match(/gitdir:\s*(.+)/);
+            if (match) {
+                const gitDir = match[1].trim();
+                // Navigate up from .git/worktrees/<name> to the repo root
+                repo = path.resolve(gitDir, "..", "..", "..");
+            }
+        }
+        catch {
+            console.error("Cannot auto-detect repo. Use --repo to specify the main repository.");
+            process.exit(1);
+        }
+    }
+    if (!repo) {
+        console.error("Cannot determine repo path. Use --repo.");
+        process.exit(1);
+    }
+    try {
+        const result = await cleanWorktree(repo, absPath, {
+            deleteBranch: opts.deleteBranch,
+        });
+        console.log(`Removed worktree: ${shortenPath(result.removedPath)}`);
+        if (result.deletedBranch) {
+            console.log(`Deleted branch: ${result.deletedBranch}`);
+        }
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program.addCommand(worktreeCmd);
 // --- Lock commands ---
 program
     .command("lock <directory>")

package/dist/core/types.d.ts

@@ -24,6 +24,7 @@ export interface AgentSession {
     };
     cost?: number;
     pid?: number;
+    group?: string;
     meta: Record<string, unknown>;
 }
 export interface LifecycleEvent {

package/dist/daemon/server.js

@@ -5,7 +5,11 @@ import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 import { ClaudeCodeAdapter } from "../adapters/claude-code.js";
+import { CodexAdapter } from "../adapters/codex.js";
 import { OpenClawAdapter } from "../adapters/openclaw.js";
+import { OpenCodeAdapter } from "../adapters/opencode.js";
+import { PiAdapter } from "../adapters/pi.js";
+import { PiRustAdapter } from "../adapters/pi-rust.js";
 import { migrateLocks } from "../migration/migrate-locks.js";
 import { FuseEngine } from "./fuse-engine.js";
 import { LockManager } from "./lock-manager.js";
@@ -32,7 +36,11 @@ export async function startDaemon(opts = {}) {
     // 5. Initialize subsystems
     const adapters = opts.adapters || {
         "claude-code": new ClaudeCodeAdapter(),
+        codex: new CodexAdapter(),
         openclaw: new OpenClawAdapter(),
+        opencode: new OpenCodeAdapter(),
+        pi: new PiAdapter(),
+        "pi-rust": new PiRustAdapter(),
     };
     const lockManager = new LockManager(state);
     const emitter = new EventEmitter();
@@ -145,11 +153,16 @@ function createRequestHandler(ctx) {
     return async (req) => {
         const params = (req.params || {});
         switch (req.method) {
-            case "session.list":
-                return ctx.sessionTracker.listSessions({
+            case "session.list": {
+                let sessions = ctx.sessionTracker.listSessions({
                     status: params.status,
                     all: params.all,
                 });
+                if (params.group) {
+                    sessions = sessions.filter((s) => s.group === params.group);
+                }
+                return sessions;
+            }
             case "session.status": {
                 const session = ctx.sessionTracker.getSession(params.id);
                 if (!session)
@@ -157,11 +170,15 @@ function createRequestHandler(ctx) {
                 return session;
             }
             case "session.peek": {
-                const adapterName = params.adapter || "claude-code";
+                // Auto-detect adapter from tracked session, fall back to param or claude-code
+                const tracked = ctx.sessionTracker.getSession(params.id);
+                const adapterName = params.adapter || tracked?.adapter || "claude-code";
                 const adapter = ctx.adapters[adapterName];
                 if (!adapter)
                     throw new Error(`Unknown adapter: ${adapterName}`);
-                return adapter.peek(params.id, {
+                // Use the full session ID if we resolved it from the tracker
+                const peekId = tracked?.id || params.id;
+                return adapter.peek(peekId, {
                     lines: params.lines,
                 });
             }
@@ -193,6 +210,10 @@ function createRequestHandler(ctx) {
                     env: params.env,
                     adapterOpts: params.adapterOpts,
                 });
+                // Propagate group tag if provided
+                if (params.group) {
+                    session.group = params.group;
+                }
                 const record = ctx.sessionTracker.track(session, adapterName);
                 // Auto-lock
                 if (cwd) {
@@ -204,6 +225,15 @@ function createRequestHandler(ctx) {
                 const session = ctx.sessionTracker.getSession(params.id);
                 if (!session)
                     throw new Error(`Session not found: ${params.id}`);
+                // Ghost pending entry with dead PID: remove from state with --force
+                if (session.id.startsWith("pending-") &&
+                    params.force &&
+                    session.pid &&
+                    !isProcessAlive(session.pid)) {
+                    ctx.lockManager.autoUnlock(session.id);
+                    ctx.sessionTracker.removeSession(session.id);
+                    return null;
+                }
                 const adapter = ctx.adapters[session.adapter];
                 if (!adapter)
                     throw new Error(`Unknown adapter: ${session.adapter}`);

package/dist/daemon/session-tracker.d.ts

@@ -3,16 +3,33 @@ import type { SessionRecord, StateManager } from "./state.js";
 export interface SessionTrackerOpts {
     adapters: Record<string, AgentAdapter>;
     pollIntervalMs?: number;
+    /** Override PID liveness check for testing (default: process.kill(pid, 0)) */
+    isProcessAlive?: (pid: number) => boolean;
 }
 export declare class SessionTracker {
     private state;
     private adapters;
     private pollIntervalMs;
     private pollHandle;
+    private polling;
+    private readonly isProcessAlive;
     constructor(state: StateManager, opts: SessionTrackerOpts);
     startPolling(): void;
+    /** Run poll() with a guard to skip if the previous cycle is still running */
+    private guardedPoll;
     stopPolling(): void;
     private poll;
+    /**
+     * Clean up ghost sessions in the daemon state:
+     * - pending-* entries whose PID matches a resolved session → remove pending
+     * - Any "running"/"idle" session in state whose PID is dead → mark stopped
+     */
+    private reapStaleEntries;
+    /**
+     * Remove stopped sessions from state that have been stopped for more than 7 days.
+     * This reduces overhead from accumulating hundreds of historical sessions.
+     */
+    private pruneOldSessions;
     /** Track a newly launched session */
     track(session: AgentSession, adapterName: string): SessionRecord;
     /** Get session record by id (exact or prefix) */
@@ -21,8 +38,11 @@ export declare class SessionTracker {
     listSessions(opts?: {
         status?: string;
         all?: boolean;
+        adapter?: string;
     }): SessionRecord[];
     activeCount(): number;
+    /** Remove a session from state entirely (used for ghost cleanup) */
+    removeSession(sessionId: string): void;
     /** Called when a session stops — returns the cwd for fuse/lock processing */
     onSessionExit(sessionId: string): SessionRecord | undefined;
 }